diff --git a/.changeset/ag-ui-events.md b/.changeset/ag-ui-events.md
new file mode 100644
index 00000000..01ad2bed
--- /dev/null
+++ b/.changeset/ag-ui-events.md
@@ -0,0 +1,20 @@
+---
+'@tanstack/ai': minor
+'@tanstack/ai-client': minor
+'@tanstack/ai-openai': minor
+'@tanstack/ai-anthropic': minor
+'@tanstack/ai-gemini': minor
+'@tanstack/ai-grok': minor
+'@tanstack/ai-ollama': minor
+'@tanstack/ai-openrouter': minor
+---
+
+feat: Add AG-UI protocol events to streaming system
+
+All text adapters now emit AG-UI protocol events only:
+
+- `RUN_STARTED` / `RUN_FINISHED` - Run lifecycle events
+- `TEXT_MESSAGE_START` / `TEXT_MESSAGE_CONTENT` / `TEXT_MESSAGE_END` - Text message streaming
+- `TOOL_CALL_START` / `TOOL_CALL_ARGS` / `TOOL_CALL_END` - Tool call streaming
+
+Only AG-UI event types are supported; previous legacy chunk formats (`content`, `tool_call`, `done`, etc.) are no longer accepted.
diff --git a/docs/guides/streaming.md b/docs/guides/streaming.md
index e8c76d00..479e9744 100644
--- a/docs/guides/streaming.md
+++ b/docs/guides/streaming.md
@@ -63,30 +63,33 @@ messages.forEach((message) => {
 });
 ```
 
-## Stream Chunks
+## Stream Events (AG-UI Protocol)
 
-Stream chunks contain different types of data:
+TanStack AI implements the [AG-UI Protocol](https://docs.ag-ui.com/introduction) for streaming. Stream events contain different types of data:
 
-- **Content chunks** - Text content being generated
-- **Thinking chunks** - Model's internal reasoning process (when supported)
-- **Tool call chunks** - When the model calls a tool
-- **Tool result chunks** - Results from tool execution
-- **Done chunks** - Stream completion
+### AG-UI Events
+
+- **RUN_STARTED** - Emitted when a run begins
+- **TEXT_MESSAGE_START/CONTENT/END** - Text content streaming lifecycle
+- **TOOL_CALL_START/ARGS/END** - Tool invocation lifecycle
+- **STEP_STARTED/STEP_FINISHED** - Thinking/reasoning steps
+- **RUN_FINISHED** - Run completion with finish reason and usage
+- **RUN_ERROR** - Error occurred during the run
 
 ### Thinking Chunks
 
-Thinking chunks represent the model's reasoning process. They stream separately from the final response text:
+Thinking/reasoning is represented by AG-UI events `STEP_STARTED` and `STEP_FINISHED`. They stream separately from the final response text:
 
 ```typescript
 for await (const chunk of stream) {
-  if (chunk.type === "thinking") {
+  if (chunk.type === "STEP_FINISHED") {
     console.log("Thinking:", chunk.content); // Accumulated thinking content
     console.log("Delta:", chunk.delta); // Incremental thinking token
   }
 }
 ```
 
-Thinking chunks are automatically converted to `ThinkingPart` in `UIMessage` objects. They are UI-only and excluded from messages sent back to the model.
+Thinking content is automatically converted to `ThinkingPart` in `UIMessage` objects. It is UI-only and excluded from messages sent back to the model.
 
 ## Connection Adapters
 
diff --git a/docs/protocol/chunk-definitions.md b/docs/protocol/chunk-definitions.md
index e0bfb585..a80f8296 100644
--- a/docs/protocol/chunk-definitions.md
+++ b/docs/protocol/chunk-definitions.md
@@ -1,348 +1,265 @@
 ---
-title: Chunk Definitions
+title: AG-UI Event Definitions
 id: chunk-definitions
 ---
 
-All streaming responses in TanStack AI consist of a series of **StreamChunks** - discrete JSON objects representing different events during the conversation. These chunks enable real-time updates for content generation, tool calls, errors, and completion signals. 
-
-This document defines the data structures (chunks) that flow between the TanStack AI server and client during streaming chat operations.
+TanStack AI implements the [AG-UI (Agent-User Interaction) Protocol](https://docs.ag-ui.com/introduction), an open, lightweight, event-based protocol that standardizes how AI agents connect to user-facing applications.
 
+All streaming responses in TanStack AI consist of a series of **AG-UI Events** - discrete JSON objects representing different stages of the conversation lifecycle. These events enable real-time updates for content generation, tool calls, thinking/reasoning, and completion signals.
 
 ## Base Structure
 
-All chunks share a common base structure:
+All AG-UI events share a common base structure:
 
 ```typescript
-interface BaseStreamChunk {
-  type: StreamChunkType;
-  id: string;          // Unique identifier for the message/response
-  model: string;       // Model identifier (e.g., "gpt-5.2", "claude-3-5-sonnet")
-  timestamp: number;   // Unix timestamp in milliseconds
+interface BaseAGUIEvent {
+  type: AGUIEventType;
+  timestamp: number;      // Unix timestamp in milliseconds
+  model?: string;         // Model identifier (TanStack AI addition)
+  rawEvent?: unknown;     // Original provider event for debugging
 }
 ```
 
-### Chunk Types
+### AG-UI Event Types
 
 ```typescript
-type StreamChunkType =
-  | 'content'              // Text content being generated
-  | 'thinking'             // Model's reasoning process (when supported)
-  | 'tool_call'            // Model calling a tool/function
-  | 'tool-input-available' // Tool inputs are ready for client execution
-  | 'approval-requested'   // Tool requires user approval
-  | 'tool_result'          // Result from tool execution
-  | 'done'                 // Stream completion
-  | 'error';               // Error occurred
+type AGUIEventType =
+  | 'RUN_STARTED'           // Run lifecycle begins
+  | 'RUN_FINISHED'          // Run completed successfully
+  | 'RUN_ERROR'             // Error occurred
+  | 'TEXT_MESSAGE_START'    // Text message begins
+  | 'TEXT_MESSAGE_CONTENT'  // Text content streaming
+  | 'TEXT_MESSAGE_END'      // Text message completes
+  | 'TOOL_CALL_START'       // Tool invocation begins
+  | 'TOOL_CALL_ARGS'        // Tool arguments streaming
+  | 'TOOL_CALL_END'         // Tool call completes (with result)
+  | 'STEP_STARTED'          // Thinking/reasoning step begins
+  | 'STEP_FINISHED'         // Thinking/reasoning step completes
+  | 'STATE_SNAPSHOT'        // Full state synchronization
+  | 'STATE_DELTA'           // Incremental state update
+  | 'CUSTOM';               // Custom extensibility events
 ```
 
-## Chunk Definitions
+Only AG-UI event types are supported; previous legacy chunk formats are no longer accepted.
+
+## AG-UI Event Definitions
 
-### ContentStreamChunk
+### RUN_STARTED
 
-Emitted when the model generates text content. Sent incrementally as tokens are generated.
+Emitted when a run begins. This is the first event in any streaming response.
 
 ```typescript
-interface ContentStreamChunk extends BaseStreamChunk {
-  type: 'content';
-  delta: string;    // The incremental content token (new text since last chunk)
-  content: string;  // Full accumulated content so far
-  role?: 'assistant';
+interface RunStartedEvent extends BaseAGUIEvent {
+  type: 'RUN_STARTED';
+  runId: string;           // Unique identifier for this run
+  threadId?: string;       // Optional thread/conversation ID
 }
 ```
 
 **Example:**
 ```json
 {
-  "type": "content",
-  "id": "chatcmpl-abc123",
-  "model": "gpt-5.2",
-  "timestamp": 1701234567890,
-  "delta": "Hello",
-  "content": "Hello",
-  "role": "assistant"
+  "type": "RUN_STARTED",
+  "runId": "run_abc123",
+  "model": "gpt-4o",
+  "timestamp": 1701234567890
 }
 ```
 
-**Usage:**
-- Display `delta` for smooth streaming effect
-- Use `content` for the complete message so far
-- Multiple content chunks will be sent for a single response
-
 ---
 
-### ThinkingStreamChunk
+### RUN_FINISHED
 
-Emitted when the model exposes its reasoning process (e.g., Claude with extended thinking, o1 models).
+Emitted when a run completes successfully.
 
 ```typescript
-interface ThinkingStreamChunk extends BaseStreamChunk {
-  type: 'thinking';
-  delta?: string;   // The incremental thinking token
-  content: string;  // Full accumulated thinking content so far
+interface RunFinishedEvent extends BaseAGUIEvent {
+  type: 'RUN_FINISHED';
+  runId: string;
+  finishReason: 'stop' | 'length' | 'content_filter' | 'tool_calls' | null;
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
 }
 ```
 
 **Example:**
 ```json
 {
-  "type": "thinking",
-  "id": "chatcmpl-abc123",
-  "model": "claude-3-5-sonnet",
-  "timestamp": 1701234567890,
-  "delta": "First, I need to",
-  "content": "First, I need to"
+  "type": "RUN_FINISHED",
+  "runId": "run_abc123",
+  "model": "gpt-4o",
+  "timestamp": 1701234567900,
+  "finishReason": "stop",
+  "usage": {
+    "promptTokens": 100,
+    "completionTokens": 50,
+    "totalTokens": 150
+  }
 }
 ```
 
-**Usage:**
-- Display in a separate "thinking" UI element
-- Thinking is excluded from messages sent back to the model
-- Not all models support thinking chunks
-
 ---
 
-### ToolCallStreamChunk
+### RUN_ERROR
 
-Emitted when the model decides to call a tool/function.
+Emitted when an error occurs during a run.
 
 ```typescript
-interface ToolCallStreamChunk extends BaseStreamChunk {
-  type: 'tool_call';
-  toolCall: {
-    id: string;
-    type: 'function';
-    function: {
-      name: string;
-      arguments: string;  // JSON string (may be partial/incremental)
-    };
+interface RunErrorEvent extends BaseAGUIEvent {
+  type: 'RUN_ERROR';
+  runId?: string;
+  error: {
+    message: string;
+    code?: string;
   };
-  index: number;  // Index of this tool call (for parallel calls)
 }
 ```
 
 **Example:**
 ```json
 {
-  "type": "tool_call",
-  "id": "chatcmpl-abc123",
-  "model": "gpt-5.2",
+  "type": "RUN_ERROR",
+  "runId": "run_abc123",
+  "model": "gpt-4o",
   "timestamp": 1701234567890,
-  "toolCall": {
-    "id": "call_abc123",
-    "type": "function",
-    "function": {
-      "name": "get_weather",
-      "arguments": "{\"location\":\"San Francisco\"}"
-    }
-  },
-  "index": 0
+  "error": {
+    "message": "Rate limit exceeded",
+    "code": "rate_limit"
+  }
 }
 ```
 
-**Usage:**
-- Multiple chunks may be sent for a single tool call (streaming arguments)
-- `arguments` may be incomplete until all chunks for this tool call are received
-- `index` allows multiple parallel tool calls
-
 ---
 
-### ToolInputAvailableStreamChunk
+### TEXT_MESSAGE_START
 
-Emitted when tool inputs are complete and ready for client-side execution.
+Emitted when a text message starts.
 
 ```typescript
-interface ToolInputAvailableStreamChunk extends BaseStreamChunk {
-  type: 'tool-input-available';
-  toolCallId: string;  // ID of the tool call
-  toolName: string;    // Name of the tool to execute
-  input: any;          // Parsed tool arguments (JSON object)
-}
-```
-
-**Example:**
-```json
-{
-  "type": "tool-input-available",
-  "id": "chatcmpl-abc123",
-  "model": "gpt-5.2",
-  "timestamp": 1701234567890,
-  "toolCallId": "call_abc123",
-  "toolName": "get_weather",
-  "input": {
-    "location": "San Francisco",
-    "unit": "fahrenheit"
-  }
+interface TextMessageStartEvent extends BaseAGUIEvent {
+  type: 'TEXT_MESSAGE_START';
+  messageId: string;
+  role: 'assistant';
 }
 ```
 
-**Usage:**
-- Signals that the client should execute the tool
-- Only sent for tools without a server-side `execute` function
-- Client calls `onToolCall` callback with these parameters
-
 ---
 
-### ApprovalRequestedStreamChunk
+### TEXT_MESSAGE_CONTENT
 
-Emitted when a tool requires user approval before execution.
+Emitted when text content is generated (streaming tokens).
 
 ```typescript
-interface ApprovalRequestedStreamChunk extends BaseStreamChunk {
-  type: 'approval-requested';
-  toolCallId: string;  // ID of the tool call
-  toolName: string;    // Name of the tool requiring approval
-  input: any;          // Tool arguments for review
-  approval: {
-    id: string;            // Unique approval request ID
-    needsApproval: true;   // Always true
-  };
+interface TextMessageContentEvent extends BaseAGUIEvent {
+  type: 'TEXT_MESSAGE_CONTENT';
+  messageId: string;
+  delta: string;       // The incremental content token
+  content?: string;    // Full accumulated content so far
 }
 ```
 
 **Example:**
 ```json
 {
-  "type": "approval-requested",
-  "id": "chatcmpl-abc123",
-  "model": "gpt-5.2",
+  "type": "TEXT_MESSAGE_CONTENT",
+  "messageId": "msg_abc123",
+  "model": "gpt-4o",
   "timestamp": 1701234567890,
-  "toolCallId": "call_abc123",
-  "toolName": "send_email",
-  "input": {
-    "to": "user@example.com",
-    "subject": "Hello",
-    "body": "Test email"
-  },
-  "approval": {
-    "id": "approval_xyz789",
-    "needsApproval": true
-  }
+  "delta": "Hello",
+  "content": "Hello"
 }
 ```
 
-**Usage:**
-- Display approval UI to user
-- User responds with approval decision via `addToolApprovalResponse()`
-- Tool execution pauses until approval is granted or denied
-
 ---
 
-### ToolResultStreamChunk
+### TEXT_MESSAGE_END
 
-Emitted when a tool execution completes (either server-side or client-side).
+Emitted when a text message completes.
 
 ```typescript
-interface ToolResultStreamChunk extends BaseStreamChunk {
-  type: 'tool_result';
-  toolCallId: string;  // ID of the tool call that was executed
-  content: string;     // Result of the tool execution (JSON stringified)
+interface TextMessageEndEvent extends BaseAGUIEvent {
+  type: 'TEXT_MESSAGE_END';
+  messageId: string;
 }
 ```
 
-**Example:**
-```json
-{
-  "type": "tool_result",
-  "id": "chatcmpl-abc123",
-  "model": "gpt-5.2",
-  "timestamp": 1701234567891,
-  "toolCallId": "call_abc123",
-  "content": "{\"temperature\":72,\"conditions\":\"sunny\"}"
+---
+
+### TOOL_CALL_START
+
+Emitted when a tool call starts.
+
+```typescript
+interface ToolCallStartEvent extends BaseAGUIEvent {
+  type: 'TOOL_CALL_START';
+  toolCallId: string;
+  toolName: string;
+  index?: number;      // Index for parallel tool calls
 }
 ```
 
-**Usage:**
-- Sent after tool execution completes
-- Model uses this result to continue the conversation
-- May trigger additional model responses
-
 ---
 
-### DoneStreamChunk
+### TOOL_CALL_ARGS
 
-Emitted when the stream completes successfully.
+Emitted when tool call arguments are streaming.
 
 ```typescript
-interface DoneStreamChunk extends BaseStreamChunk {
-  type: 'done';
-  finishReason: 'stop' | 'length' | 'content_filter' | 'tool_calls' | null;
-  usage?: {
-    promptTokens: number;
-    completionTokens: number;
-    totalTokens: number;
-  };
+interface ToolCallArgsEvent extends BaseAGUIEvent {
+  type: 'TOOL_CALL_ARGS';
+  toolCallId: string;
+  delta: string;       // Incremental JSON arguments delta
+  args?: string;       // Full accumulated arguments so far
 }
 ```
 
-**Example:**
-```json
-{
-  "type": "done",
-  "id": "chatcmpl-abc123",
-  "model": "gpt-5.2",
-  "timestamp": 1701234567892,
-  "finishReason": "stop",
-  "usage": {
-    "promptTokens": 150,
-    "completionTokens": 75,
-    "totalTokens": 225
-  }
-}
-```
+---
 
-**Finish Reasons:**
-- `stop` - Natural completion
-- `length` - Reached max tokens
-- `content_filter` - Stopped by content filtering
-- `tool_calls` - Stopped to execute tools
-- `null` - Unknown or not provided
+### TOOL_CALL_END
 
-**Usage:**
-- Marks the end of a successful stream
-- Clean up streaming state
-- Display token usage (if available)
+Emitted when a tool call completes.
+
+```typescript
+interface ToolCallEndEvent extends BaseAGUIEvent {
+  type: 'TOOL_CALL_END';
+  toolCallId: string;
+  toolName: string;
+  input?: unknown;     // Final parsed input arguments
+  result?: string;     // Tool execution result (if executed)
+}
+```
 
 ---
 
-### ErrorStreamChunk
+### STEP_STARTED
 
-Emitted when an error occurs during streaming.
+Emitted when a thinking/reasoning step starts.
 
 ```typescript
-interface ErrorStreamChunk extends BaseStreamChunk {
-  type: 'error';
-  error: {
-    message: string;  // Human-readable error message
-    code?: string;    // Optional error code
-  };
+interface StepStartedEvent extends BaseAGUIEvent {
+  type: 'STEP_STARTED';
+  stepId: string;
+  stepType?: string;   // e.g., 'thinking', 'planning'
 }
 ```
 
-**Example:**
-```json
-{
-  "type": "error",
-  "id": "chatcmpl-abc123",
-  "model": "gpt-5.2",
-  "timestamp": 1701234567893,
-  "error": {
-    "message": "Rate limit exceeded",
-    "code": "rate_limit_exceeded"
-  }
-}
-```
+---
 
-**Common Error Codes:**
-- `rate_limit_exceeded` - API rate limit hit
-- `invalid_request` - Malformed request
-- `authentication_error` - API key issues
-- `timeout` - Request timed out
-- `server_error` - Internal server error
+### STEP_FINISHED
 
-**Usage:**
-- Display error to user
-- Stream ends after error chunk
-- Retry logic should be implemented client-side
+Emitted when a thinking/reasoning step finishes.
+
+```typescript
+interface StepFinishedEvent extends BaseAGUIEvent {
+  type: 'STEP_FINISHED';
+  stepId: string;
+  delta?: string;      // Incremental thinking content
+  content?: string;    // Full accumulated thinking content
+}
+```
 
 ---
 
@@ -352,38 +269,50 @@ interface ErrorStreamChunk extends BaseStreamChunk {
 
 1. **Content Generation:**
    ```
-   ContentStreamChunk (delta: "Hello")
-   ContentStreamChunk (delta: " world")
-   ContentStreamChunk (delta: "!")
-   DoneStreamChunk (finishReason: "stop")
+   RUN_STARTED
+   TEXT_MESSAGE_START
+   TEXT_MESSAGE_CONTENT (delta: "Hello")
+   TEXT_MESSAGE_CONTENT (delta: " world")
+   TEXT_MESSAGE_CONTENT (delta: "!")
+   TEXT_MESSAGE_END
+   RUN_FINISHED (finishReason: "stop")
    ```
 
 2. **With Thinking:**
    ```
-   ThinkingStreamChunk (delta: "I need to...")
-   ThinkingStreamChunk (delta: " check the weather")
-   ContentStreamChunk (delta: "Let me check")
-   DoneStreamChunk (finishReason: "stop")
+   RUN_STARTED
+   STEP_STARTED (stepType: "thinking")
+   STEP_FINISHED (delta: "I need to...")
+   STEP_FINISHED (delta: " check the weather")
+   TEXT_MESSAGE_START
+   TEXT_MESSAGE_CONTENT (delta: "Let me check")
+   TEXT_MESSAGE_END
+   RUN_FINISHED (finishReason: "stop")
    ```
 
 3. **Tool Usage:**
    ```
-   ToolCallStreamChunk (name: "get_weather")
-   ToolResultStreamChunk (content: "{...}")
-   ContentStreamChunk (delta: "The weather is...")
-   DoneStreamChunk (finishReason: "stop")
+   RUN_STARTED
+   TOOL_CALL_START (name: "get_weather")
+   TOOL_CALL_ARGS / TOOL_CALL_END (result: "{...}")
+   TEXT_MESSAGE_START
+   TEXT_MESSAGE_CONTENT (delta: "The weather is...")
+   TEXT_MESSAGE_END
+   RUN_FINISHED (finishReason: "stop")
    ```
 
 4. **Client Tool with Approval:**
    ```
-   ToolCallStreamChunk (name: "send_email")
-   ApprovalRequestedStreamChunk (toolName: "send_email")
+   RUN_STARTED
+   TOOL_CALL_START (name: "send_email")
+   TOOL_CALL_ARGS / TOOL_CALL_END
+   CUSTOM (name: "approval-requested")
    [User approves]
-   ToolInputAvailableStreamChunk (toolName: "send_email")
    [Client executes]
-   ToolResultStreamChunk (content: "{\"sent\":true}")
-   ContentStreamChunk (delta: "Email sent successfully")
-   DoneStreamChunk (finishReason: "stop")
+   TEXT_MESSAGE_START
+   TEXT_MESSAGE_CONTENT (delta: "Email sent successfully")
+   TEXT_MESSAGE_END
+   RUN_FINISHED (finishReason: "stop")
    ```
 
 ### Multiple Tool Calls
@@ -391,30 +320,39 @@ interface ErrorStreamChunk extends BaseStreamChunk {
 When the model calls multiple tools in parallel:
 
 ```
-ToolCallStreamChunk (index: 0, name: "get_weather")
-ToolCallStreamChunk (index: 1, name: "get_time")
-ToolResultStreamChunk (toolCallId: "call_1")
-ToolResultStreamChunk (toolCallId: "call_2")
-ContentStreamChunk (delta: "Based on the data...")
-DoneStreamChunk (finishReason: "stop")
+RUN_STARTED
+TOOL_CALL_START (index: 0, name: "get_weather")
+TOOL_CALL_START (index: 1, name: "get_time")
+TOOL_CALL_END (toolCallId: "call_1", result: "...")
+TOOL_CALL_END (toolCallId: "call_2", result: "...")
+TEXT_MESSAGE_START
+TEXT_MESSAGE_CONTENT (delta: "Based on the data...")
+TEXT_MESSAGE_END
+RUN_FINISHED (finishReason: "stop")
 ```
 
 ---
 
 ## TypeScript Union Type
 
-All chunks are represented as a discriminated union:
+All chunks are represented as the AG-UI event union (`StreamChunk = AGUIEvent`):
 
 ```typescript
 type StreamChunk =
-  | ContentStreamChunk
-  | ThinkingStreamChunk
-  | ToolCallStreamChunk
-  | ToolInputAvailableStreamChunk
-  | ApprovalRequestedStreamChunk
-  | ToolResultStreamChunk
-  | DoneStreamChunk
-  | ErrorStreamChunk;
+  | RunStartedEvent
+  | RunFinishedEvent
+  | RunErrorEvent
+  | TextMessageStartEvent
+  | TextMessageContentEvent
+  | TextMessageEndEvent
+  | ToolCallStartEvent
+  | ToolCallArgsEvent
+  | ToolCallEndEvent
+  | StepStartedEvent
+  | StepFinishedEvent
+  | StateSnapshotEvent
+  | StateDeltaEvent
+  | CustomEvent;
 ```
 
 This enables type-safe handling in TypeScript:
@@ -422,14 +360,14 @@ This enables type-safe handling in TypeScript:
 ```typescript
 function handleChunk(chunk: StreamChunk) {
   switch (chunk.type) {
-    case 'content':
-      console.log(chunk.delta); // TypeScript knows this is ContentStreamChunk
+    case 'TEXT_MESSAGE_CONTENT':
+      console.log(chunk.delta);
       break;
-    case 'thinking':
-      console.log(chunk.content); // TypeScript knows this is ThinkingStreamChunk
+    case 'STEP_FINISHED':
+      console.log(chunk.content);
       break;
-    case 'tool_call':
-      console.log(chunk.toolCall.function.name); // TypeScript knows structure
+    case 'TOOL_CALL_START':
+      console.log(chunk.toolName);
       break;
     // ... other cases
   }
diff --git a/examples/ts-react-chat/src/lib/model-selection.ts b/examples/ts-react-chat/src/lib/model-selection.ts
index acfea50b..a767428e 100644
--- a/examples/ts-react-chat/src/lib/model-selection.ts
+++ b/examples/ts-react-chat/src/lib/model-selection.ts
@@ -38,13 +38,18 @@ export const MODEL_OPTIONS: Array<ModelOption> = [
   // Gemini
   {
     provider: 'gemini',
-    model: 'gemini-2.0-flash-exp',
+    model: 'gemini-2.0-flash',
     label: 'Gemini - 2.0 Flash',
   },
   {
     provider: 'gemini',
     model: 'gemini-2.5-flash',
-    label: 'Gemini 2.5 - Flash',
+    label: 'Gemini - 2.5 Flash',
+  },
+  {
+    provider: 'gemini',
+    model: 'gemini-2.5-pro',
+    label: 'Gemini - 2.5 Pro',
   },
 
   // Openrouter
@@ -87,6 +92,16 @@ export const MODEL_OPTIONS: Array<ModelOption> = [
   },
 
   // Grok
+  {
+    provider: 'grok',
+    model: 'grok-4',
+    label: 'Grok - Grok 4',
+  },
+  {
+    provider: 'grok',
+    model: 'grok-4-fast-non-reasoning',
+    label: 'Grok - Grok 4 Fast',
+  },
   {
     provider: 'grok',
     model: 'grok-3',
@@ -97,47 +112,6 @@ export const MODEL_OPTIONS: Array<ModelOption> = [
     model: 'grok-3-mini',
     label: 'Grok - Grok 3 Mini',
   },
-  {
-    provider: 'grok',
-    model: 'grok-2-vision-1212',
-    label: 'Grok - Grok 2 Vision',
-  },
 ]
 
-const STORAGE_KEY = 'tanstack-ai-model-preference'
-
-export function getStoredModelPreference(): ModelOption | null {
-  if (typeof window === 'undefined') return null
-
-  try {
-    const stored = localStorage.getItem(STORAGE_KEY)
-    if (!stored) return null
-
-    const parsed = JSON.parse(stored) as { provider: Provider; model: string }
-    const option = MODEL_OPTIONS.find(
-      (opt) => opt.provider === parsed.provider && opt.model === parsed.model,
-    )
-
-    return option || null
-  } catch {
-    return null
-  }
-}
-
-export function setStoredModelPreference(option: ModelOption): void {
-  if (typeof window === 'undefined') return
-
-  try {
-    localStorage.setItem(
-      STORAGE_KEY,
-      JSON.stringify({ provider: option.provider, model: option.model }),
-    )
-  } catch {
-    // Ignore storage errors
-  }
-}
-
-export function getDefaultModelOption(): ModelOption {
-  const stored = getStoredModelPreference()
-  return stored || MODEL_OPTIONS[0]
-}
+export const DEFAULT_MODEL_OPTION = MODEL_OPTIONS[0]
diff --git a/examples/ts-react-chat/src/routes/api.tanchat.ts b/examples/ts-react-chat/src/routes/api.tanchat.ts
index 6fd2eba7..f011927c 100644
--- a/examples/ts-react-chat/src/routes/api.tanchat.ts
+++ b/examples/ts-react-chat/src/routes/api.tanchat.ts
@@ -124,12 +124,10 @@ export const Route = createFileRoute('/api/tanchat')({
             createChatOptions({
               adapter: ollamaText((model || 'gpt-oss:120b') as 'gpt-oss:120b'),
               modelOptions: { think: 'low', options: { top_k: 1 } },
-              temperature: 12,
             }),
           openai: () =>
             createChatOptions({
               adapter: openaiText((model || 'gpt-4o') as 'gpt-4o'),
-              temperature: 2,
               modelOptions: {},
             }),
         }
diff --git a/examples/ts-react-chat/src/routes/index.tsx b/examples/ts-react-chat/src/routes/index.tsx
index 7c0fc6fa..c9436c7a 100644
--- a/examples/ts-react-chat/src/routes/index.tsx
+++ b/examples/ts-react-chat/src/routes/index.tsx
@@ -18,11 +18,7 @@ import {
   getPersonalGuitarPreferenceToolDef,
   recommendGuitarToolDef,
 } from '@/lib/guitar-tools'
-import {
-  MODEL_OPTIONS,
-  getDefaultModelOption,
-  setStoredModelPreference,
-} from '@/lib/model-selection'
+import { DEFAULT_MODEL_OPTION, MODEL_OPTIONS } from '@/lib/model-selection'
 
 const getPersonalGuitarPreferenceToolClient =
   getPersonalGuitarPreferenceToolDef.client(() => ({ preference: 'acoustic' }))
@@ -228,9 +224,8 @@ function Messages({
 }
 
 function ChatPage() {
-  const [selectedModel, setSelectedModel] = useState<ModelOption>(() =>
-    getDefaultModelOption(),
-  )
+  const [selectedModel, setSelectedModel] =
+    useState<ModelOption>(DEFAULT_MODEL_OPTION)
 
   const body = useMemo(
     () => ({
@@ -268,7 +263,6 @@ function ChatPage() {
                 onChange={(e) => {
                   const option = MODEL_OPTIONS[parseInt(e.target.value)]
                   setSelectedModel(option)
-                  setStoredModelPreference(option)
                 }}
                 disabled={isLoading}
                 className="w-full rounded-lg border border-orange-500/20 bg-gray-900 px-3 py-2 text-sm text-white focus:outline-none focus:ring-2 focus:ring-orange-500/50 disabled:opacity-50"
diff --git a/examples/ts-svelte-chat/src/lib/model-selection.ts b/examples/ts-svelte-chat/src/lib/model-selection.ts
index 0412d275..0f66fb3f 100644
--- a/examples/ts-svelte-chat/src/lib/model-selection.ts
+++ b/examples/ts-svelte-chat/src/lib/model-selection.ts
@@ -32,13 +32,18 @@ export const MODEL_OPTIONS: Array<ModelOption> = [
   // Gemini
   {
     provider: 'gemini',
-    model: 'gemini-2.0-flash-exp',
+    model: 'gemini-2.0-flash',
     label: 'Gemini - 2.0 Flash',
   },
   {
     provider: 'gemini',
-    model: 'gemini-exp-1206',
-    label: 'Gemini - Exp 1206 (Pro)',
+    model: 'gemini-2.5-flash',
+    label: 'Gemini - 2.5 Flash',
+  },
+  {
+    provider: 'gemini',
+    model: 'gemini-2.5-pro',
+    label: 'Gemini - 2.5 Pro',
   },
 
   // Ollama
diff --git a/examples/ts-svelte-chat/src/routes/api/chat/+server.ts b/examples/ts-svelte-chat/src/routes/api/chat/+server.ts
index 9cd6eb88..6308af35 100644
--- a/examples/ts-svelte-chat/src/routes/api/chat/+server.ts
+++ b/examples/ts-svelte-chat/src/routes/api/chat/+server.ts
@@ -37,7 +37,7 @@ const adapterConfig = {
     }),
   gemini: () =>
     createChatOptions({
-      adapter: geminiText('gemini-2.0-flash-exp'),
+      adapter: geminiText('gemini-2.0-flash'),
     }),
   ollama: () =>
     createChatOptions({
diff --git a/examples/ts-vue-chat/src/lib/model-selection.ts b/examples/ts-vue-chat/src/lib/model-selection.ts
index 0412d275..0f66fb3f 100644
--- a/examples/ts-vue-chat/src/lib/model-selection.ts
+++ b/examples/ts-vue-chat/src/lib/model-selection.ts
@@ -32,13 +32,18 @@ export const MODEL_OPTIONS: Array<ModelOption> = [
   // Gemini
   {
     provider: 'gemini',
-    model: 'gemini-2.0-flash-exp',
+    model: 'gemini-2.0-flash',
     label: 'Gemini - 2.0 Flash',
   },
   {
     provider: 'gemini',
-    model: 'gemini-exp-1206',
-    label: 'Gemini - Exp 1206 (Pro)',
+    model: 'gemini-2.5-flash',
+    label: 'Gemini - 2.5 Flash',
+  },
+  {
+    provider: 'gemini',
+    model: 'gemini-2.5-pro',
+    label: 'Gemini - 2.5 Pro',
   },
 
   // Ollama
diff --git a/examples/ts-vue-chat/vite.config.ts b/examples/ts-vue-chat/vite.config.ts
index 21a58c4d..74c3563f 100644
--- a/examples/ts-vue-chat/vite.config.ts
+++ b/examples/ts-vue-chat/vite.config.ts
@@ -211,7 +211,7 @@ export default defineConfig({
                 adapter = anthropicText(selectedModel)
                 break
               case 'gemini':
-                selectedModel = model || 'gemini-2.0-flash-exp'
+                selectedModel = model || 'gemini-2.0-flash'
                 adapter = geminiText(selectedModel)
                 break
               case 'ollama':
diff --git a/knip.json b/knip.json
index 26f314b6..ff6abde1 100644
--- a/knip.json
+++ b/knip.json
@@ -3,6 +3,7 @@
   "ignoreDependencies": ["@faker-js/faker"],
   "ignoreWorkspaces": ["examples/**", "testing/**", "**/smoke-tests/**"],
   "ignore": [
+    "scripts/**",
     "packages/typescript/ai-openai/live-tests/**",
     "packages/typescript/ai-openai/src/**/*.test.ts",
     "packages/typescript/ai-openai/src/audio/audio-provider-options.ts",
diff --git a/packages/php/tanstack-ai/src/SSEFormatter.php b/packages/php/tanstack-ai/src/SSEFormatter.php
index 0d330fce..05c86ae4 100644
--- a/packages/php/tanstack-ai/src/SSEFormatter.php
+++ b/packages/php/tanstack-ai/src/SSEFormatter.php
@@ -32,18 +32,23 @@ public static function formatDone(): string
     }
 
     /**
-     * Format an error as an SSE error chunk.
+     * Format an error as an SSE RUN_ERROR chunk (AG-UI Protocol).
      * 
      * @param \Throwable $error Exception to format
-     * @return string SSE-formatted error chunk
+     * @param string|null $runId Optional run ID for correlation
+     * @param string|null $model Optional model name
+     * @return string SSE-formatted RUN_ERROR chunk
      */
-    public static function formatError(\Throwable $error): string
+    public static function formatError(\Throwable $error, ?string $runId = null, ?string $model = null): string
     {
         $errorChunk = [
-            'type' => 'error',
+            'type' => 'RUN_ERROR',
+            'runId' => $runId ?? ('run-' . bin2hex(random_bytes(4))),
+            'model' => $model,
+            'timestamp' => (int)(microtime(true) * 1000),
             'error' => [
-                'type' => get_class($error),
-                'message' => $error->getMessage()
+                'message' => $error->getMessage(),
+                'code' => (string)$error->getCode()
             ]
         ];
         return self::formatChunk($errorChunk);
diff --git a/packages/php/tanstack-ai/src/StreamChunkConverter.php b/packages/php/tanstack-ai/src/StreamChunkConverter.php
index 39e1e4e7..a2214543 100644
--- a/packages/php/tanstack-ai/src/StreamChunkConverter.php
+++ b/packages/php/tanstack-ai/src/StreamChunkConverter.php
@@ -3,7 +3,13 @@
 namespace TanStack\AI;
 
 /**
- * Converts provider-specific streaming events to TanStack AI StreamChunk format.
+ * Converts provider-specific streaming events to TanStack AI AG-UI StreamChunk format.
+ * 
+ * Implements the AG-UI (Agent-User Interaction) Protocol event types:
+ * - RUN_STARTED, RUN_FINISHED, RUN_ERROR (lifecycle events)
+ * - TEXT_MESSAGE_START, TEXT_MESSAGE_CONTENT, TEXT_MESSAGE_END (text streaming)
+ * - TOOL_CALL_START, TOOL_CALL_ARGS, TOOL_CALL_END (tool calling)
+ * - STEP_STARTED, STEP_FINISHED (thinking/reasoning)
  * 
  * Supports:
  * - Anthropic streaming events
@@ -15,15 +21,25 @@ class StreamChunkConverter
     private string $provider;
     private int $timestamp;
     private string $accumulatedContent = '';
+    private string $accumulatedThinking = '';
     private array $toolCallsMap = [];
     private int $currentToolIndex = -1;
-    private bool $doneEmitted = false;
+    private bool $runFinished = false;
+
+    // AG-UI lifecycle tracking
+    private string $runId;
+    private string $messageId;
+    private ?string $stepId = null;
+    private bool $hasEmittedRunStarted = false;
+    private bool $hasEmittedTextMessageStart = false;
 
     public function __construct(string $model, string $provider = 'anthropic')
     {
         $this->model = $model;
         $this->provider = strtolower($provider);
         $this->timestamp = (int)(microtime(true) * 1000);
+        $this->runId = $this->generateId();
+        $this->messageId = $this->generateId();
     }
 
     /**
@@ -60,40 +76,118 @@ private function getAttr(mixed $obj, string $attr, mixed $default = null): mixed
     }
 
     /**
-     * Convert Anthropic streaming event to StreamChunk format
+     * Create RUN_STARTED event if not already emitted
+     */
+    private function maybeEmitRunStarted(): ?array
+    {
+        if (!$this->hasEmittedRunStarted) {
+            $this->hasEmittedRunStarted = true;
+            return [
+                'type' => 'RUN_STARTED',
+                'runId' => $this->runId,
+                'model' => $this->model,
+                'timestamp' => $this->timestamp
+            ];
+        }
+        return null;
+    }
+
+    /**
+     * Create TEXT_MESSAGE_START event if not already emitted
+     */
+    private function maybeEmitTextMessageStart(): ?array
+    {
+        if (!$this->hasEmittedTextMessageStart) {
+            $this->hasEmittedTextMessageStart = true;
+            return [
+                'type' => 'TEXT_MESSAGE_START',
+                'messageId' => $this->messageId,
+                'model' => $this->model,
+                'timestamp' => $this->timestamp,
+                'role' => 'assistant'
+            ];
+        }
+        return null;
+    }
+
+    /**
+     * Convert Anthropic streaming event to AG-UI StreamChunk format
      */
     public function convertAnthropicEvent(mixed $event): array
     {
         $chunks = [];
         $eventType = $this->getEventType($event);
 
+        // Emit RUN_STARTED on first event
+        $runStarted = $this->maybeEmitRunStarted();
+        if ($runStarted) {
+            $chunks[] = $runStarted;
+        }
+
         if ($eventType === 'content_block_start') {
-            // Tool call is starting
             $contentBlock = $this->getAttr($event, 'content_block');
-            if ($contentBlock && $this->getAttr($contentBlock, 'type') === 'tool_use') {
-                $this->currentToolIndex++;
-                $this->toolCallsMap[$this->currentToolIndex] = [
-                    'id' => $this->getAttr($contentBlock, 'id'),
-                    'name' => $this->getAttr($contentBlock, 'name'),
-                    'input' => ''
-                ];
+            if ($contentBlock) {
+                $blockType = $this->getAttr($contentBlock, 'type');
+                
+                if ($blockType === 'tool_use') {
+                    // Tool call is starting
+                    $this->currentToolIndex++;
+                    $toolId = $this->getAttr($contentBlock, 'id');
+                    $toolName = $this->getAttr($contentBlock, 'name');
+                    
+                    $this->toolCallsMap[$this->currentToolIndex] = [
+                        'id' => $toolId,
+                        'name' => $toolName,
+                        'input' => '',
+                        'started' => false
+                    ];
+                } elseif ($blockType === 'thinking') {
+                    // Thinking/reasoning block starting
+                    $this->accumulatedThinking = '';
+                    $this->stepId = $this->generateId();
+                    $chunks[] = [
+                        'type' => 'STEP_STARTED',
+                        'stepId' => $this->stepId,
+                        'model' => $this->model,
+                        'timestamp' => $this->timestamp,
+                        'stepType' => 'thinking'
+                    ];
+                }
             }
         } elseif ($eventType === 'content_block_delta') {
             $delta = $this->getAttr($event, 'delta');
 
             if ($delta && $this->getAttr($delta, 'type') === 'text_delta') {
+                // Emit TEXT_MESSAGE_START on first text content
+                $textStart = $this->maybeEmitTextMessageStart();
+                if ($textStart) {
+                    $chunks[] = $textStart;
+                }
+
                 // Text content delta
                 $deltaText = $this->getAttr($delta, 'text', '');
                 $this->accumulatedContent .= $deltaText;
 
                 $chunks[] = [
-                    'type' => 'content',
-                    'id' => $this->generateId(),
+                    'type' => 'TEXT_MESSAGE_CONTENT',
+                    'messageId' => $this->messageId,
                     'model' => $this->model,
                     'timestamp' => $this->timestamp,
                     'delta' => $deltaText,
-                    'content' => $this->accumulatedContent,
-                    'role' => 'assistant'
+                    'content' => $this->accumulatedContent
+                ];
+            } elseif ($delta && $this->getAttr($delta, 'type') === 'thinking_delta') {
+                // Thinking content delta
+                $deltaThinking = $this->getAttr($delta, 'thinking', '');
+                $this->accumulatedThinking .= $deltaThinking;
+
+                $chunks[] = [
+                    'type' => 'STEP_FINISHED',
+                    'stepId' => $this->stepId ?? $this->generateId(),
+                    'model' => $this->model,
+                    'timestamp' => $this->timestamp,
+                    'delta' => $deltaThinking,
+                    'content' => $this->accumulatedThinking
                 ];
             } elseif ($delta && $this->getAttr($delta, 'type') === 'input_json_delta') {
                 // Tool input is being streamed
@@ -101,25 +195,81 @@ public function convertAnthropicEvent(mixed $event): array
                 $toolCall = $this->toolCallsMap[$this->currentToolIndex] ?? null;
 
                 if ($toolCall) {
+                    // Emit TOOL_CALL_START on first args delta
+                    if (!$toolCall['started']) {
+                        $toolCall['started'] = true;
+                        $this->toolCallsMap[$this->currentToolIndex] = $toolCall;
+                        
+                        $chunks[] = [
+                            'type' => 'TOOL_CALL_START',
+                            'toolCallId' => $toolCall['id'],
+                            'toolName' => $toolCall['name'],
+                            'model' => $this->model,
+                            'timestamp' => $this->timestamp,
+                            'index' => $this->currentToolIndex
+                        ];
+                    }
+
                     $toolCall['input'] .= $partialJson;
                     $this->toolCallsMap[$this->currentToolIndex] = $toolCall;
 
                     $chunks[] = [
-                        'type' => 'tool_call',
-                        'id' => $this->generateId(),
+                        'type' => 'TOOL_CALL_ARGS',
+                        'toolCallId' => $toolCall['id'],
+                        'model' => $this->model,
+                        'timestamp' => $this->timestamp,
+                        'delta' => $partialJson,
+                        'args' => $toolCall['input']
+                    ];
+                }
+            }
+        } elseif ($eventType === 'content_block_stop') {
+            // Content block completed
+            $toolCall = $this->toolCallsMap[$this->currentToolIndex] ?? null;
+            if ($toolCall) {
+                // If tool call wasn't started yet (no args), start it now
+                if (!$toolCall['started']) {
+                    $toolCall['started'] = true;
+                    $this->toolCallsMap[$this->currentToolIndex] = $toolCall;
+                    
+                    $chunks[] = [
+                        'type' => 'TOOL_CALL_START',
+                        'toolCallId' => $toolCall['id'],
+                        'toolName' => $toolCall['name'],
                         'model' => $this->model,
                         'timestamp' => $this->timestamp,
-                        'toolCall' => [
-                            'id' => $toolCall['id'],
-                            'type' => 'function',
-                            'function' => [
-                                'name' => $toolCall['name'],
-                                'arguments' => $partialJson // Incremental JSON
-                            ]
-                        ],
                         'index' => $this->currentToolIndex
                     ];
                 }
+
+                // Parse input and emit TOOL_CALL_END
+                $parsedInput = [];
+                if (!empty($toolCall['input'])) {
+                    try {
+                        $parsedInput = json_decode($toolCall['input'], true) ?? [];
+                    } catch (\Exception $e) {
+                        $parsedInput = [];
+                    }
+                }
+
+                $chunks[] = [
+                    'type' => 'TOOL_CALL_END',
+                    'toolCallId' => $toolCall['id'],
+                    'toolName' => $toolCall['name'],
+                    'model' => $this->model,
+                    'timestamp' => $this->timestamp,
+                    'input' => $parsedInput
+                ];
+            }
+
+            // Emit TEXT_MESSAGE_END if we had text content
+            if ($this->hasEmittedTextMessageStart && !empty($this->accumulatedContent)) {
+                $chunks[] = [
+                    'type' => 'TEXT_MESSAGE_END',
+                    'messageId' => $this->messageId,
+                    'model' => $this->model,
+                    'timestamp' => $this->timestamp
+                ];
             }
         } elseif ($eventType === 'message_delta') {
             // Message metadata update (includes stop_reason and usage)
@@ -132,6 +282,7 @@ public function convertAnthropicEvent(mixed $event): array
                 $finishReason = match ($stopReason) {
                     'tool_use' => 'tool_calls',
                     'end_turn' => 'stop',
+                    'max_tokens' => 'length',
                     default => $stopReason
                 };
 
@@ -144,23 +295,38 @@ public function convertAnthropicEvent(mixed $event): array
                     ];
                 }
 
-                $this->doneEmitted = true;
-                $chunks[] = [
-                    'type' => 'done',
-                    'id' => $this->generateId(),
-                    'model' => $this->model,
-                    'timestamp' => $this->timestamp,
-                    'finishReason' => $finishReason,
-                    'usage' => $usageDict
-                ];
+                // Handle max_tokens as error
+                if ($stopReason === 'max_tokens') {
+                    $this->runFinished = true;
+                    $chunks[] = [
+                        'type' => 'RUN_ERROR',
+                        'runId' => $this->runId,
+                        'model' => $this->model,
+                        'timestamp' => $this->timestamp,
+                        'error' => [
+                            'message' => 'The response was cut off because the maximum token limit was reached.',
+                            'code' => 'max_tokens'
+                        ]
+                    ];
+                } else {
+                    $this->runFinished = true;
+                    $chunks[] = [
+                        'type' => 'RUN_FINISHED',
+                        'runId' => $this->runId,
+                        'model' => $this->model,
+                        'timestamp' => $this->timestamp,
+                        'finishReason' => $finishReason,
+                        'usage' => $usageDict
+                    ];
+                }
             }
         } elseif ($eventType === 'message_stop') {
-            // Stream completed - this is a fallback if message_delta didn't emit done
-            if (!$this->doneEmitted) {
-                $this->doneEmitted = true;
+            // Stream completed - this is a fallback if message_delta didn't emit RUN_FINISHED
+            if (!$this->runFinished) {
+                $this->runFinished = true;
                 $chunks[] = [
-                    'type' => 'done',
-                    'id' => $this->generateId(),
+                    'type' => 'RUN_FINISHED',
+                    'runId' => $this->runId,
                     'model' => $this->model,
                     'timestamp' => $this->timestamp,
                     'finishReason' => 'stop'
@@ -172,12 +338,18 @@ public function convertAnthropicEvent(mixed $event): array
     }
 
     /**
-     * Convert OpenAI streaming event to StreamChunk format
+     * Convert OpenAI streaming event to AG-UI StreamChunk format
      */
     public function convertOpenAIEvent(mixed $event): array
     {
         $chunks = [];
 
+        // Emit RUN_STARTED on first event
+        $runStarted = $this->maybeEmitRunStarted();
+        if ($runStarted) {
+            $chunks[] = $runStarted;
+        }
+
         // OpenAI events have chunk.choices[0].delta structure
         $choices = $this->getAttr($event, 'choices', []);
         $choice = !empty($choices) ? $choices[0] : $event;
@@ -188,15 +360,20 @@ public function convertOpenAIEvent(mixed $event): array
         if ($delta) {
             $content = $this->getAttr($delta, 'content');
             if ($content !== null) {
+                // Emit TEXT_MESSAGE_START on first text content
+                $textStart = $this->maybeEmitTextMessageStart();
+                if ($textStart) {
+                    $chunks[] = $textStart;
+                }
+
                 $this->accumulatedContent .= $content;
                 $chunks[] = [
-                    'type' => 'content',
-                    'id' => $this->getAttr($event, 'id', $this->generateId()),
+                    'type' => 'TEXT_MESSAGE_CONTENT',
+                    'messageId' => $this->messageId,
                     'model' => $this->getAttr($event, 'model', $this->model),
                     'timestamp' => $this->timestamp,
                     'delta' => $content,
-                    'content' => $this->accumulatedContent,
-                    'role' => 'assistant'
+                    'content' => $this->accumulatedContent
                 ];
             }
 
@@ -204,22 +381,57 @@ public function convertOpenAIEvent(mixed $event): array
             $toolCalls = $this->getAttr($delta, 'tool_calls');
             if ($toolCalls) {
                 foreach ($toolCalls as $index => $toolCall) {
+                    $toolIndex = $this->getAttr($toolCall, 'index', $index);
+                    $toolId = $this->getAttr($toolCall, 'id');
                     $function = $this->getAttr($toolCall, 'function', []);
-                    $chunks[] = [
-                        'type' => 'tool_call',
-                        'id' => $this->getAttr($event, 'id', $this->generateId()),
-                        'model' => $this->getAttr($event, 'model', $this->model),
-                        'timestamp' => $this->timestamp,
-                        'toolCall' => [
-                            'id' => $this->getAttr($toolCall, 'id', 'call_' . $this->timestamp),
-                            'type' => 'function',
-                            'function' => [
-                                'name' => $this->getAttr($function, 'name', ''),
-                                'arguments' => $this->getAttr($function, 'arguments', '')
-                            ]
-                        ],
-                        'index' => $this->getAttr($toolCall, 'index', $index)
-                    ];
+                    $toolName = $this->getAttr($function, 'name', '');
+                    $arguments = $this->getAttr($function, 'arguments', '');
+
+                    // Initialize tool call tracking if new
+                    if (!isset($this->toolCallsMap[$toolIndex])) {
+                        $this->toolCallsMap[$toolIndex] = [
+                            'id' => $toolId ?? ('call_' . $this->timestamp . '_' . $toolIndex),
+                            'name' => $toolName,
+                            'input' => '',
+                            'started' => false
+                        ];
+                    }
+
+                    $tracked = &$this->toolCallsMap[$toolIndex];
+                    
+                    // Update tool ID and name if provided
+                    if ($toolId) {
+                        $tracked['id'] = $toolId;
+                    }
+                    if ($toolName) {
+                        $tracked['name'] = $toolName;
+                    }
+
+                    // Emit TOOL_CALL_START on first encounter
+                    if (!$tracked['started'] && ($toolId || $toolName)) {
+                        $tracked['started'] = true;
+                        $chunks[] = [
+                            'type' => 'TOOL_CALL_START',
+                            'toolCallId' => $tracked['id'],
+                            'toolName' => $tracked['name'],
+                            'model' => $this->getAttr($event, 'model', $this->model),
+                            'timestamp' => $this->timestamp,
+                            'index' => $toolIndex
+                        ];
+                    }
+
+                    // Accumulate arguments
+                    if ($arguments) {
+                        $tracked['input'] .= $arguments;
+                        $chunks[] = [
+                            'type' => 'TOOL_CALL_ARGS',
+                            'toolCallId' => $tracked['id'],
+                            'model' => $this->getAttr($event, 'model', $this->model),
+                            'timestamp' => $this->timestamp,
+                            'delta' => $arguments,
+                            'args' => $tracked['input']
+                        ];
+                    }
                 }
             }
         }
@@ -227,6 +439,39 @@ public function convertOpenAIEvent(mixed $event): array
         // Handle completion
         $finishReason = $this->getAttr($choice, 'finish_reason');
         if ($finishReason) {
+            // Emit TOOL_CALL_END for all pending tool calls
+            foreach ($this->toolCallsMap as $toolCall) {
+                if ($toolCall['started']) {
+                    $parsedInput = [];
+                    if (!empty($toolCall['input'])) {
+                        try {
+                            $parsedInput = json_decode($toolCall['input'], true) ?? [];
+                        } catch (\Exception $e) {
+                            $parsedInput = [];
+                        }
+                    }
+
+                    $chunks[] = [
+                        'type' => 'TOOL_CALL_END',
+                        'toolCallId' => $toolCall['id'],
+                        'toolName' => $toolCall['name'],
+                        'model' => $this->getAttr($event, 'model', $this->model),
+                        'timestamp' => $this->timestamp,
+                        'input' => $parsedInput
+                    ];
+                }
+            }
+
+            // Emit TEXT_MESSAGE_END if we had text content
+            if ($this->hasEmittedTextMessageStart) {
+                $chunks[] = [
+                    'type' => 'TEXT_MESSAGE_END',
+                    'messageId' => $this->messageId,
+                    'model' => $this->getAttr($event, 'model', $this->model),
+                    'timestamp' => $this->timestamp
+                ];
+            }
+
             $usage = $this->getAttr($event, 'usage');
             $usageDict = null;
             if ($usage) {
@@ -237,13 +482,22 @@ public function convertOpenAIEvent(mixed $event): array
                 ];
             }
 
-            $this->doneEmitted = true;
+            // Map OpenAI finish reasons
+            $mappedFinishReason = match ($finishReason) {
+                'stop' => 'stop',
+                'length' => 'length',
+                'tool_calls' => 'tool_calls',
+                'content_filter' => 'content_filter',
+                default => $finishReason
+            };
+
+            $this->runFinished = true;
             $chunks[] = [
-                'type' => 'done',
-                'id' => $this->getAttr($event, 'id', $this->generateId()),
+                'type' => 'RUN_FINISHED',
+                'runId' => $this->runId,
                 'model' => $this->getAttr($event, 'model', $this->model),
                 'timestamp' => $this->timestamp,
-                'finishReason' => $finishReason,
+                'finishReason' => $mappedFinishReason,
                 'usage' => $usageDict
             ];
         }
@@ -252,7 +506,7 @@ public function convertOpenAIEvent(mixed $event): array
     }
 
     /**
-     * Convert provider streaming event to StreamChunk format.
+     * Convert provider streaming event to AG-UI StreamChunk format.
      * Automatically detects provider based on event structure.
      */
     public function convertEvent(mixed $event): array
@@ -267,7 +521,7 @@ public function convertEvent(mixed $event): array
 
             // Anthropic events have types like "content_block_start", "message_delta"
             // OpenAI events have chunk.choices structure
-            if (in_array($eventType, ['content_block_start', 'content_block_delta', 'message_delta', 'message_stop'])) {
+            if (in_array($eventType, ['content_block_start', 'content_block_delta', 'content_block_stop', 'message_delta', 'message_stop'])) {
                 return $this->convertAnthropicEvent($event);
             } elseif ($this->getAttr($event, 'choices') !== null) {
                 return $this->convertOpenAIEvent($event);
@@ -279,20 +533,29 @@ public function convertEvent(mixed $event): array
     }
 
     /**
-     * Convert an error to ErrorStreamChunk format
+     * Convert an error to RUN_ERROR StreamChunk format (AG-UI Protocol)
      */
     public function convertError(\Throwable $error): array
     {
-        return [
-            'type' => 'error',
-            'id' => $this->generateId(),
+        // Ensure RUN_STARTED was emitted before error
+        $chunks = [];
+        $runStarted = $this->maybeEmitRunStarted();
+        if ($runStarted) {
+            $chunks[] = $runStarted;
+        }
+
+        $chunks[] = [
+            'type' => 'RUN_ERROR',
+            'runId' => $this->runId,
             'model' => $this->model,
             'timestamp' => $this->timestamp,
             'error' => [
                 'message' => $error->getMessage(),
-                'code' => $error->getCode()
+                'code' => (string)$error->getCode()
             ]
         ];
+
+        return $chunks;
     }
 }
 
diff --git a/packages/python/tanstack-ai/src/tanstack_ai/__init__.py b/packages/python/tanstack-ai/src/tanstack_ai/__init__.py
index a55f21e2..46e39da4 100644
--- a/packages/python/tanstack-ai/src/tanstack_ai/__init__.py
+++ b/packages/python/tanstack-ai/src/tanstack_ai/__init__.py
@@ -39,27 +39,37 @@
     ModelMessage,
     ChatOptions,
     AIAdapterConfig,
-    # Stream chunk types
+    # AG-UI Event types
+    AGUIEventType,
+    AGUIEvent,
+    RunStartedEvent,
+    RunFinishedEvent,
+    RunErrorEvent,
+    TextMessageStartEvent,
+    TextMessageContentEvent,
+    TextMessageEndEvent,
+    ToolCallStartEvent,
+    ToolCallArgsEvent,
+    ToolCallEndEvent,
+    StepStartedEvent,
+    StepFinishedEvent,
+    StateSnapshotEvent,
+    StateDeltaEvent,
+    CustomEvent,
     StreamChunk,
-    ContentStreamChunk,
-    ThinkingStreamChunk,
-    ToolCallStreamChunk,
-    ToolInputAvailableStreamChunk,
-    ApprovalRequestedStreamChunk,
-    ToolResultStreamChunk,
-    DoneStreamChunk,
-    ErrorStreamChunk,
     # Agent loop types
     AgentLoopState,
     AgentLoopStrategy,
     # Other types
+    UsageInfo,
+    ErrorInfo,
     SummarizationOptions,
     SummarizationResult,
     EmbeddingOptions,
     EmbeddingResult,
 )
 
-# Legacy utilities (for backward compatibility)
+# Utilities
 from .converter import StreamChunkConverter
 from .message_formatters import format_messages_for_anthropic, format_messages_for_openai
 from .sse import format_sse_chunk, format_sse_done, format_sse_error, stream_chunks_to_sse
@@ -83,28 +93,41 @@
     "max_iterations",
     "until_finish_reason",
     "combine_strategies",
-    # Types
+    # AG-UI Event Types
+    "AGUIEventType",
+    "AGUIEvent",
+    "RunStartedEvent",
+    "RunFinishedEvent",
+    "RunErrorEvent",
+    "TextMessageStartEvent",
+    "TextMessageContentEvent",
+    "TextMessageEndEvent",
+    "ToolCallStartEvent",
+    "ToolCallArgsEvent",
+    "ToolCallEndEvent",
+    "StepStartedEvent",
+    "StepFinishedEvent",
+    "StateSnapshotEvent",
+    "StateDeltaEvent",
+    "CustomEvent",
+    "StreamChunk",
+    # Core Types
     "Tool",
     "ToolCall",
     "ModelMessage",
     "ChatOptions",
     "AIAdapterConfig",
-    "StreamChunk",
-    "ContentStreamChunk",
-    "ThinkingStreamChunk",
-    "ToolCallStreamChunk",
-    "ToolInputAvailableStreamChunk",
-    "ApprovalRequestedStreamChunk",
-    "ToolResultStreamChunk",
-    "DoneStreamChunk",
-    "ErrorStreamChunk",
+    "UsageInfo",
+    "ErrorInfo",
+    # Agent Loop Types
     "AgentLoopState",
     "AgentLoopStrategy",
+    # Other Types
     "SummarizationOptions",
     "SummarizationResult",
     "EmbeddingOptions",
     "EmbeddingResult",
-    # Legacy utilities
+    # Utilities
     "StreamChunkConverter",
     "format_messages_for_anthropic",
     "format_messages_for_openai",
diff --git a/packages/python/tanstack-ai/src/tanstack_ai/anthropic_adapter.py b/packages/python/tanstack-ai/src/tanstack_ai/anthropic_adapter.py
index a3ba0cd2..7e179c39 100644
--- a/packages/python/tanstack-ai/src/tanstack_ai/anthropic_adapter.py
+++ b/packages/python/tanstack-ai/src/tanstack_ai/anthropic_adapter.py
@@ -28,16 +28,22 @@
 from .types import (
     AIAdapterConfig,
     ChatOptions,
-    ContentStreamChunk,
-    DoneStreamChunk,
     EmbeddingOptions,
     EmbeddingResult,
-    ErrorStreamChunk,
+    RunErrorEvent,
+    RunFinishedEvent,
+    RunStartedEvent,
+    StepFinishedEvent,
+    StepStartedEvent,
     StreamChunk,
     SummarizationOptions,
     SummarizationResult,
-    ThinkingStreamChunk,
-    ToolCallStreamChunk,
+    TextMessageContentEvent,
+    TextMessageEndEvent,
+    TextMessageStartEvent,
+    ToolCallArgsEvent,
+    ToolCallEndEvent,
+    ToolCallStartEvent,
 )
 
 
@@ -96,14 +102,21 @@ def models(self) -> List[str]:
 
     async def chat_stream(self, options: ChatOptions) -> AsyncIterator[StreamChunk]:
         """
-        Stream chat completions from Anthropic.
+        Stream chat completions from Anthropic using AG-UI Protocol events.
 
         Args:
             options: Chat options
 
         Yields:
-            StreamChunk objects
+            AG-UI StreamChunk events (RUN_STARTED, TEXT_MESSAGE_CONTENT, etc.)
         """
+        # AG-UI lifecycle tracking
+        run_id = self._generate_id()
+        message_id = self._generate_id()
+        step_id: Optional[str] = None
+        has_emitted_run_started = False
+        has_emitted_text_message_start = False
+        
         try:
             # Format messages for Anthropic (function returns tuple of (system, messages))
             system_prompt, formatted_messages = format_messages_for_anthropic(
@@ -144,18 +157,29 @@ async def chat_stream(self, options: ChatOptions) -> AsyncIterator[StreamChunk]:
                 request_params.update(options.provider_options)
 
             # Make the streaming request
-            message_id = self._generate_id()
             accumulated_content = ""
             accumulated_thinking = ""
             tool_calls: Dict[int, Dict[str, Any]] = {}
+            current_tool_index = -1
 
             async with self.client.messages.stream(**request_params) as stream:
                 async for event in stream:
                     timestamp = int(time.time() * 1000)
 
+                    # Emit RUN_STARTED on first event
+                    if not has_emitted_run_started:
+                        has_emitted_run_started = True
+                        yield RunStartedEvent(
+                            type="RUN_STARTED",
+                            runId=run_id,
+                            model=options.model,
+                            timestamp=timestamp,
+                            threadId=None,
+                        )
+
                     # Handle different event types
                     if event.type == "message_start":
-                        # Message started - we could emit metadata here
+                        # Message started - metadata handled above
                         pass
 
                     elif event.type == "content_block_start":
@@ -163,61 +187,178 @@ async def chat_stream(self, options: ChatOptions) -> AsyncIterator[StreamChunk]:
                         block = event.content_block
                         if hasattr(block, "type"):
                             if block.type == "text":
-                                # Text content block
+                                # Text content block - will emit TEXT_MESSAGE_START on first delta
                                 pass
                             elif block.type == "tool_use":
-                                # Tool use block
-                                tool_calls[event.index] = {
+                                # Tool use block starting
+                                current_tool_index += 1
+                                tool_calls[current_tool_index] = {
                                     "id": block.id,
-                                    "type": "function",
-                                    "function": {
-                                        "name": block.name,
-                                        "arguments": "",
-                                    },
+                                    "name": block.name,
+                                    "input": "",
+                                    "started": False,
                                 }
+                            elif block.type == "thinking":
+                                # Thinking block starting
+                                accumulated_thinking = ""
+                                step_id = self._generate_id()
+                                yield StepStartedEvent(
+                                    type="STEP_STARTED",
+                                    stepId=step_id,
+                                    model=options.model,
+                                    timestamp=timestamp,
+                                    stepType="thinking",
+                                )
 
                     elif event.type == "content_block_delta":
                         delta = event.delta
                         if hasattr(delta, "type"):
                             if delta.type == "text_delta":
+                                # Emit TEXT_MESSAGE_START on first text content
+                                if not has_emitted_text_message_start:
+                                    has_emitted_text_message_start = True
+                                    yield TextMessageStartEvent(
+                                        type="TEXT_MESSAGE_START",
+                                        messageId=message_id,
+                                        model=options.model,
+                                        timestamp=timestamp,
+                                        role="assistant",
+                                    )
+
                                 # Text content delta
                                 accumulated_content += delta.text
-                                yield ContentStreamChunk(
-                                    type="content",
-                                    id=message_id,
+                                yield TextMessageContentEvent(
+                                    type="TEXT_MESSAGE_CONTENT",
+                                    messageId=message_id,
                                     model=options.model,
                                     timestamp=timestamp,
                                     delta=delta.text,
                                     content=accumulated_content,
-                                    role="assistant",
+                                )
+                            elif delta.type == "thinking_delta":
+                                # Thinking content delta
+                                thinking_text = getattr(delta, "thinking", "")
+                                accumulated_thinking += thinking_text
+                                yield StepFinishedEvent(
+                                    type="STEP_FINISHED",
+                                    stepId=step_id or self._generate_id(),
+                                    model=options.model,
+                                    timestamp=timestamp,
+                                    delta=thinking_text,
+                                    content=accumulated_thinking,
                                 )
                             elif delta.type == "input_json_delta":
                                 # Tool input delta
-                                if event.index in tool_calls:
-                                    tool_calls[event.index]["function"][
-                                        "arguments"
-                                    ] += delta.partial_json
+                                if current_tool_index in tool_calls:
+                                    tool_call = tool_calls[current_tool_index]
+                                    
+                                    # Emit TOOL_CALL_START on first args delta
+                                    if not tool_call["started"]:
+                                        tool_call["started"] = True
+                                        yield ToolCallStartEvent(
+                                            type="TOOL_CALL_START",
+                                            toolCallId=tool_call["id"],
+                                            toolName=tool_call["name"],
+                                            model=options.model,
+                                            timestamp=timestamp,
+                                            index=current_tool_index,
+                                        )
+
+                                    tool_call["input"] += delta.partial_json
+                                    yield ToolCallArgsEvent(
+                                        type="TOOL_CALL_ARGS",
+                                        toolCallId=tool_call["id"],
+                                        model=options.model,
+                                        timestamp=timestamp,
+                                        delta=delta.partial_json,
+                                        args=tool_call["input"],
+                                    )
 
                     elif event.type == "content_block_stop":
                         # Content block completed
-                        if event.index in tool_calls:
-                            # Emit tool call chunk
-                            tool_call = tool_calls[event.index]
-                            yield ToolCallStreamChunk(
-                                type="tool_call",
-                                id=message_id,
+                        if current_tool_index in tool_calls:
+                            tool_call = tool_calls[current_tool_index]
+                            
+                            # If tool call wasn't started yet (no args), start it now
+                            if not tool_call["started"]:
+                                tool_call["started"] = True
+                                yield ToolCallStartEvent(
+                                    type="TOOL_CALL_START",
+                                    toolCallId=tool_call["id"],
+                                    toolName=tool_call["name"],
+                                    model=options.model,
+                                    timestamp=timestamp,
+                                    index=current_tool_index,
+                                )
+
+                            # Parse input and emit TOOL_CALL_END
+                            parsed_input = {}
+                            if tool_call["input"]:
+                                try:
+                                    parsed_input = json.loads(tool_call["input"])
+                                except json.JSONDecodeError:
+                                    parsed_input = {}
+
+                            yield ToolCallEndEvent(
+                                type="TOOL_CALL_END",
+                                toolCallId=tool_call["id"],
+                                toolName=tool_call["name"],
+                                model=options.model,
+                                timestamp=timestamp,
+                                input=parsed_input,
+                            )
+
+                        # Emit TEXT_MESSAGE_END if we had text content
+                        if has_emitted_text_message_start and accumulated_content:
+                            yield TextMessageEndEvent(
+                                type="TEXT_MESSAGE_END",
+                                messageId=message_id,
                                 model=options.model,
                                 timestamp=timestamp,
-                                toolCall=tool_call,
-                                index=event.index,
                             )
 
                     elif event.type == "message_delta":
                         # Message metadata delta (finish reason, usage)
-                        pass
+                        delta = event.delta
+                        if hasattr(delta, "stop_reason") and delta.stop_reason:
+                            usage = None
+                            if hasattr(event, "usage") and event.usage:
+                                usage = {
+                                    "promptTokens": event.usage.input_tokens,
+                                    "completionTokens": event.usage.output_tokens,
+                                    "totalTokens": event.usage.input_tokens
+                                    + event.usage.output_tokens,
+                                }
+
+                            # Map Anthropic stop_reason to TanStack format
+                            if delta.stop_reason == "max_tokens":
+                                yield RunErrorEvent(
+                                    type="RUN_ERROR",
+                                    runId=run_id,
+                                    model=options.model,
+                                    timestamp=timestamp,
+                                    error={
+                                        "message": "The response was cut off because the maximum token limit was reached.",
+                                        "code": "max_tokens",
+                                    },
+                                )
+                            else:
+                                finish_reason = {
+                                    "end_turn": "stop",
+                                    "tool_use": "tool_calls",
+                                }.get(delta.stop_reason, "stop")
+
+                                yield RunFinishedEvent(
+                                    type="RUN_FINISHED",
+                                    runId=run_id,
+                                    model=options.model,
+                                    timestamp=timestamp,
+                                    finishReason=finish_reason,
+                                    usage=usage,
+                                )
 
                     elif event.type == "message_stop":
-                        # Message completed - emit done chunk
+                        # Message completed - emit RUN_FINISHED if not already done
                         final_message = await stream.get_final_message()
                         usage = None
                         if hasattr(final_message, "usage"):
@@ -229,29 +370,28 @@ async def chat_stream(self, options: ChatOptions) -> AsyncIterator[StreamChunk]:
                             }
 
                         # Determine finish reason
-                        finish_reason = None
+                        finish_reason = "stop"
                         if hasattr(final_message, "stop_reason"):
-                            if final_message.stop_reason == "end_turn":
-                                finish_reason = "stop"
-                            elif final_message.stop_reason == "max_tokens":
-                                finish_reason = "length"
-                            elif final_message.stop_reason == "tool_use":
-                                finish_reason = "tool_calls"
-
-                        yield DoneStreamChunk(
-                            type="done",
-                            id=message_id,
+                            finish_reason = {
+                                "end_turn": "stop",
+                                "max_tokens": "length",
+                                "tool_use": "tool_calls",
+                            }.get(final_message.stop_reason, "stop")
+
+                        yield RunFinishedEvent(
+                            type="RUN_FINISHED",
+                            runId=run_id,
                             model=options.model,
-                            timestamp=timestamp,
+                            timestamp=int(time.time() * 1000),
                             finishReason=finish_reason,
                             usage=usage,
                         )
 
         except Exception as e:
-            # Emit error chunk
-            yield ErrorStreamChunk(
-                type="error",
-                id=self._generate_id(),
+            # Emit RUN_ERROR
+            yield RunErrorEvent(
+                type="RUN_ERROR",
+                runId=run_id,
                 model=options.model,
                 timestamp=int(time.time() * 1000),
                 error={
diff --git a/packages/python/tanstack-ai/src/tanstack_ai/chat.py b/packages/python/tanstack-ai/src/tanstack_ai/chat.py
index 93edd10d..36d2ab86 100644
--- a/packages/python/tanstack-ai/src/tanstack_ai/chat.py
+++ b/packages/python/tanstack-ai/src/tanstack_ai/chat.py
@@ -22,15 +22,14 @@
 )
 from .types import (
     AgentLoopStrategy,
-    ApprovalRequestedStreamChunk,
     ChatOptions,
-    DoneStreamChunk,
+    CustomEvent,
     ModelMessage,
+    RunFinishedEvent,
     StreamChunk,
     Tool,
     ToolCall,
-    ToolInputAvailableStreamChunk,
-    ToolResultStreamChunk,
+    ToolCallEndEvent,
 )
 
 
@@ -119,7 +118,7 @@ def __init__(
         self.last_finish_reason: Optional[str] = None
         self.current_message_id: Optional[str] = None
         self.accumulated_content = ""
-        self.done_chunk: Optional[DoneStreamChunk] = None
+        self.finished_event: Optional[RunFinishedEvent] = None
         self.should_emit_stream_end = True
         self.early_termination = False
         self.tool_phase: ToolPhaseResult = ToolPhaseResult.CONTINUE
@@ -181,7 +180,7 @@ def _begin_iteration(self) -> None:
         """Begin a new iteration."""
         self.current_message_id = self._create_id("msg")
         self.accumulated_content = ""
-        self.done_chunk = None
+        self.finished_event = None
 
     async def _stream_model_response(self) -> AsyncIterator[StreamChunk]:
         """
@@ -215,28 +214,33 @@ def _handle_stream_chunk(self, chunk: StreamChunk) -> None:
         """
         chunk_type = chunk.get("type")
 
-        if chunk_type == "content":
-            self.accumulated_content = chunk["content"]
-        elif chunk_type == "tool_call":
-            self.tool_call_manager.add_tool_call_chunk(chunk)
-        elif chunk_type == "done":
-            self._handle_done_chunk(chunk)
-        elif chunk_type == "error":
+        if chunk_type == "TEXT_MESSAGE_CONTENT":
+            if chunk.get("content"):
+                self.accumulated_content = chunk["content"]
+            else:
+                self.accumulated_content += chunk.get("delta", "")
+        elif chunk_type == "TOOL_CALL_START":
+            self.tool_call_manager.add_tool_call_start_event(chunk)
+        elif chunk_type == "TOOL_CALL_ARGS":
+            self.tool_call_manager.add_tool_call_args_event(chunk)
+        elif chunk_type == "RUN_FINISHED":
+            self._handle_run_finished_event(chunk)
+        elif chunk_type == "RUN_ERROR":
             self.early_termination = True
             self.should_emit_stream_end = False
 
-    def _handle_done_chunk(self, chunk: DoneStreamChunk) -> None:
-        """Handle a done chunk."""
+    def _handle_run_finished_event(self, chunk: RunFinishedEvent) -> None:
+        """Handle a RUN_FINISHED event."""
         # Don't overwrite a tool_calls finishReason with a stop finishReason
         if (
-            self.done_chunk
-            and self.done_chunk.get("finishReason") == "tool_calls"
+            self.finished_event
+            and self.finished_event.get("finishReason") == "tool_calls"
             and chunk.get("finishReason") == "stop"
         ):
             self.last_finish_reason = chunk.get("finishReason")
             return
 
-        self.done_chunk = chunk
+        self.finished_event = chunk
         self.last_finish_reason = chunk.get("finishReason")
 
     async def _check_for_pending_tool_calls(self) -> AsyncIterator[StreamChunk]:
@@ -250,7 +254,7 @@ async def _check_for_pending_tool_calls(self) -> AsyncIterator[StreamChunk]:
         if not pending_tool_calls:
             return
 
-        done_chunk = self._create_synthetic_done_chunk()
+        finish_event = self._create_synthetic_finished_event()
 
         # Collect client state
         approvals, client_tool_results = self._collect_client_state()
@@ -266,12 +270,12 @@ async def _check_for_pending_tool_calls(self) -> AsyncIterator[StreamChunk]:
         # Handle approval requests
         if execution_result.needs_approval or execution_result.needs_client_execution:
             async for chunk in self._emit_approval_requests(
-                execution_result.needs_approval, done_chunk
+                execution_result.needs_approval, finish_event
             ):
                 yield chunk
 
             async for chunk in self._emit_client_tool_inputs(
-                execution_result.needs_client_execution, done_chunk
+                execution_result.needs_client_execution, finish_event
             ):
                 yield chunk
 
@@ -280,7 +284,7 @@ async def _check_for_pending_tool_calls(self) -> AsyncIterator[StreamChunk]:
             return
 
         # Emit tool results
-        async for chunk in self._emit_tool_results(execution_result.results, done_chunk):
+        async for chunk in self._emit_tool_results(execution_result.results, finish_event):
             yield chunk
 
     async def _process_tool_calls(self) -> AsyncIterator[StreamChunk]:
@@ -295,9 +299,9 @@ async def _process_tool_calls(self) -> AsyncIterator[StreamChunk]:
             return
 
         tool_calls = self.tool_call_manager.get_tool_calls()
-        done_chunk = self.done_chunk
+        finish_event = self.finished_event
 
-        if not done_chunk or not tool_calls:
+        if not finish_event or not tool_calls:
             self._set_tool_phase(ToolPhaseResult.STOP)
             return
 
@@ -318,12 +322,12 @@ async def _process_tool_calls(self) -> AsyncIterator[StreamChunk]:
         # Handle approval requests
         if execution_result.needs_approval or execution_result.needs_client_execution:
             async for chunk in self._emit_approval_requests(
-                execution_result.needs_approval, done_chunk
+                execution_result.needs_approval, finish_event
             ):
                 yield chunk
 
             async for chunk in self._emit_client_tool_inputs(
-                execution_result.needs_client_execution, done_chunk
+                execution_result.needs_client_execution, finish_event
             ):
                 yield chunk
 
@@ -331,7 +335,7 @@ async def _process_tool_calls(self) -> AsyncIterator[StreamChunk]:
             return
 
         # Emit tool results
-        async for chunk in self._emit_tool_results(execution_result.results, done_chunk):
+        async for chunk in self._emit_tool_results(execution_result.results, finish_event):
             yield chunk
 
         self.tool_call_manager.clear()
@@ -340,8 +344,8 @@ async def _process_tool_calls(self) -> AsyncIterator[StreamChunk]:
     def _should_execute_tool_phase(self) -> bool:
         """Check if we should execute the tool phase."""
         return (
-            self.done_chunk is not None
-            and self.done_chunk.get("finishReason") == "tool_calls"
+            self.finished_event is not None
+            and self.finished_event.get("finishReason") == "tool_calls"
             and len(self.tools) > 0
             and self.tool_call_manager.has_tool_calls()
         )
@@ -373,21 +377,23 @@ def _collect_client_state(self) -> tuple[Dict[str, bool], Dict[str, Any]]:
     async def _emit_approval_requests(
         self,
         approval_requests: List[ApprovalRequest],
-        done_chunk: DoneStreamChunk,
+        finish_event: RunFinishedEvent,
     ) -> AsyncIterator[StreamChunk]:
-        """Emit approval request chunks."""
+        """Emit approval request events using CUSTOM event type."""
         for approval in approval_requests:
-            chunk: ApprovalRequestedStreamChunk = {
-                "type": "approval-requested",
-                "id": done_chunk["id"],
-                "model": done_chunk["model"],
+            chunk: CustomEvent = {
+                "type": "CUSTOM",
                 "timestamp": int(time.time() * 1000),
-                "toolCallId": approval.tool_call_id,
-                "toolName": approval.tool_name,
-                "input": approval.input,
-                "approval": {
-                    "id": approval.approval_id,
-                    "needsApproval": True,
+                "model": finish_event.get("model"),
+                "name": "approval-requested",
+                "data": {
+                    "toolCallId": approval.tool_call_id,
+                    "toolName": approval.tool_name,
+                    "input": approval.input,
+                    "approval": {
+                        "id": approval.approval_id,
+                        "needsApproval": True,
+                    },
                 },
             }
             yield chunk
@@ -395,37 +401,39 @@ async def _emit_approval_requests(
     async def _emit_client_tool_inputs(
         self,
         client_requests: List[ClientToolRequest],
-        done_chunk: DoneStreamChunk,
+        finish_event: RunFinishedEvent,
     ) -> AsyncIterator[StreamChunk]:
-        """Emit tool-input-available chunks for client execution."""
+        """Emit tool-input-available events using CUSTOM event type."""
         for client_tool in client_requests:
-            chunk: ToolInputAvailableStreamChunk = {
-                "type": "tool-input-available",
-                "id": done_chunk["id"],
-                "model": done_chunk["model"],
+            chunk: CustomEvent = {
+                "type": "CUSTOM",
                 "timestamp": int(time.time() * 1000),
-                "toolCallId": client_tool.tool_call_id,
-                "toolName": client_tool.tool_name,
-                "input": client_tool.input,
+                "model": finish_event.get("model"),
+                "name": "tool-input-available",
+                "data": {
+                    "toolCallId": client_tool.tool_call_id,
+                    "toolName": client_tool.tool_name,
+                    "input": client_tool.input,
+                },
             }
             yield chunk
 
     async def _emit_tool_results(
         self,
         results: List[ToolResult],
-        done_chunk: DoneStreamChunk,
+        finish_event: RunFinishedEvent,
     ) -> AsyncIterator[StreamChunk]:
-        """Emit tool result chunks and add to messages."""
+        """Emit TOOL_CALL_END events and add to messages."""
         for result in results:
             content = json.dumps(result.result)
 
-            chunk: ToolResultStreamChunk = {
-                "type": "tool_result",
-                "id": done_chunk["id"],
-                "model": done_chunk["model"],
+            chunk: ToolCallEndEvent = {
+                "type": "TOOL_CALL_END",
                 "timestamp": int(time.time() * 1000),
+                "model": finish_event.get("model"),
                 "toolCallId": result.tool_call_id,
-                "content": content,
+                "toolName": result.tool_name,
+                "result": content,
             }
             yield chunk
 
@@ -454,11 +462,11 @@ def _get_pending_tool_calls_from_messages(self) -> List[ToolCall]:
 
         return pending
 
-    def _create_synthetic_done_chunk(self) -> DoneStreamChunk:
-        """Create a synthetic done chunk for pending tool calls."""
+    def _create_synthetic_finished_event(self) -> RunFinishedEvent:
+        """Create a synthetic RUN_FINISHED event for pending tool calls."""
         return {
-            "type": "done",
-            "id": self._create_id("pending"),
+            "type": "RUN_FINISHED",
+            "runId": self._create_id("pending"),
             "model": self.options.model,
             "timestamp": int(time.time() * 1000),
             "finishReason": "tool_calls",
diff --git a/packages/python/tanstack-ai/src/tanstack_ai/converter.py b/packages/python/tanstack-ai/src/tanstack_ai/converter.py
index 2ee9e541..b47e5cfa 100644
--- a/packages/python/tanstack-ai/src/tanstack_ai/converter.py
+++ b/packages/python/tanstack-ai/src/tanstack_ai/converter.py
@@ -2,8 +2,15 @@
 TanStack AI Stream Chunk Converter
 
 Converts streaming events from various AI providers (Anthropic, OpenAI) 
-into TanStack AI StreamChunk format.
+into TanStack AI AG-UI StreamChunk format.
+
+Implements the AG-UI (Agent-User Interaction) Protocol event types:
+- RUN_STARTED, RUN_FINISHED, RUN_ERROR (lifecycle events)
+- TEXT_MESSAGE_START, TEXT_MESSAGE_CONTENT, TEXT_MESSAGE_END (text streaming)
+- TOOL_CALL_START, TOOL_CALL_ARGS, TOOL_CALL_END (tool calling)
+- STEP_STARTED, STEP_FINISHED (thinking/reasoning)
 """
+import json
 import uuid
 from typing import List, Dict, Any, Optional
 from datetime import datetime
@@ -11,7 +18,7 @@
 
 class StreamChunkConverter:
     """
-    Converts provider-specific streaming events to TanStack AI StreamChunk format.
+    Converts provider-specific streaming events to TanStack AI AG-UI StreamChunk format.
     
     Supports:
     - Anthropic streaming events
@@ -30,9 +37,17 @@ def __init__(self, model: str, provider: str = "anthropic"):
         self.provider = provider.lower()
         self.timestamp = int(datetime.now().timestamp() * 1000)
         self.accumulated_content = ""
+        self.accumulated_thinking = ""
         self.tool_calls_map: Dict[int, Dict[str, Any]] = {}
         self.current_tool_index = -1
-        self.done_emitted = False
+        self.run_finished = False
+        
+        # AG-UI lifecycle tracking
+        self.run_id = self.generate_id()
+        self.message_id = self.generate_id()
+        self.step_id: Optional[str] = None
+        self.has_emitted_run_started = False
+        self.has_emitted_text_message_start = False
     
     def generate_id(self) -> str:
         """Generate a unique ID for the chunk"""
@@ -50,38 +65,104 @@ def _get_attr(self, obj: Any, attr: str, default: Any = None) -> Any:
             return obj.get(attr, default)
         return getattr(obj, attr, default)
     
+    def _maybe_emit_run_started(self) -> Optional[Dict[str, Any]]:
+        """Create RUN_STARTED event if not already emitted"""
+        if not self.has_emitted_run_started:
+            self.has_emitted_run_started = True
+            return {
+                "type": "RUN_STARTED",
+                "runId": self.run_id,
+                "model": self.model,
+                "timestamp": self.timestamp
+            }
+        return None
+    
+    def _maybe_emit_text_message_start(self) -> Optional[Dict[str, Any]]:
+        """Create TEXT_MESSAGE_START event if not already emitted"""
+        if not self.has_emitted_text_message_start:
+            self.has_emitted_text_message_start = True
+            return {
+                "type": "TEXT_MESSAGE_START",
+                "messageId": self.message_id,
+                "model": self.model,
+                "timestamp": self.timestamp,
+                "role": "assistant"
+            }
+        return None
+    
     async def convert_anthropic_event(self, event: Any) -> List[Dict[str, Any]]:
-        """Convert Anthropic streaming event to StreamChunk format"""
+        """Convert Anthropic streaming event to AG-UI StreamChunk format"""
         chunks = []
         event_type = self._get_event_type(event)
         
+        # Emit RUN_STARTED on first event
+        run_started = self._maybe_emit_run_started()
+        if run_started:
+            chunks.append(run_started)
+        
         if event_type == "content_block_start":
-            # Tool call is starting
             content_block = self._get_attr(event, "content_block")
-            if content_block and self._get_attr(content_block, "type") == "tool_use":
-                self.current_tool_index += 1
-                self.tool_calls_map[self.current_tool_index] = {
-                    "id": self._get_attr(content_block, "id"),
-                    "name": self._get_attr(content_block, "name"),
-                    "input": ""
-                }
+            if content_block:
+                block_type = self._get_attr(content_block, "type")
+                
+                if block_type == "tool_use":
+                    # Tool call is starting
+                    self.current_tool_index += 1
+                    tool_id = self._get_attr(content_block, "id")
+                    tool_name = self._get_attr(content_block, "name")
+                    
+                    self.tool_calls_map[self.current_tool_index] = {
+                        "id": tool_id,
+                        "name": tool_name,
+                        "input": "",
+                        "started": False
+                    }
+                elif block_type == "thinking":
+                    # Thinking/reasoning block starting
+                    self.accumulated_thinking = ""
+                    self.step_id = self.generate_id()
+                    chunks.append({
+                        "type": "STEP_STARTED",
+                        "stepId": self.step_id,
+                        "model": self.model,
+                        "timestamp": self.timestamp,
+                        "stepType": "thinking"
+                    })
         
         elif event_type == "content_block_delta":
             delta = self._get_attr(event, "delta")
             
             if delta and self._get_attr(delta, "type") == "text_delta":
+                # Emit TEXT_MESSAGE_START on first text content
+                text_start = self._maybe_emit_text_message_start()
+                if text_start:
+                    chunks.append(text_start)
+                
                 # Text content delta
                 delta_text = self._get_attr(delta, "text", "")
                 self.accumulated_content += delta_text
                 
                 chunks.append({
-                    "type": "content",
-                    "id": self.generate_id(),
+                    "type": "TEXT_MESSAGE_CONTENT",
+                    "messageId": self.message_id,
                     "model": self.model,
                     "timestamp": self.timestamp,
                     "delta": delta_text,
-                    "content": self.accumulated_content,
-                    "role": "assistant"
+                    "content": self.accumulated_content
+                })
+            
+            elif delta and self._get_attr(delta, "type") == "thinking_delta":
+                # Thinking content delta
+                delta_thinking = self._get_attr(delta, "thinking", "")
+                self.accumulated_thinking += delta_thinking
+                
+                chunks.append({
+                    "type": "STEP_FINISHED",
+                    "stepId": self.step_id or self.generate_id(),
+                    "model": self.model,
+                    "timestamp": self.timestamp,
+                    "delta": delta_thinking,
+                    "content": self.accumulated_thinking
                 })
             
             elif delta and self._get_attr(delta, "type") == "input_json_delta":
@@ -90,23 +171,70 @@ async def convert_anthropic_event(self, event: Any) -> List[Dict[str, Any]]:
                 tool_call = self.tool_calls_map.get(self.current_tool_index)
                 
                 if tool_call:
+                    # Emit TOOL_CALL_START on first args delta
+                    if not tool_call["started"]:
+                        tool_call["started"] = True
+                        chunks.append({
+                            "type": "TOOL_CALL_START",
+                            "toolCallId": tool_call["id"],
+                            "toolName": tool_call["name"],
+                            "model": self.model,
+                            "timestamp": self.timestamp,
+                            "index": self.current_tool_index
+                        })
+                    
                     tool_call["input"] += partial_json
                     
                     chunks.append({
-                        "type": "tool_call",
-                        "id": self.generate_id(),
+                        "type": "TOOL_CALL_ARGS",
+                        "toolCallId": tool_call["id"],
+                        "model": self.model,
+                        "timestamp": self.timestamp,
+                        "delta": partial_json,
+                        "args": tool_call["input"]
+                    })
+        
+        elif event_type == "content_block_stop":
+            # Content block completed
+            tool_call = self.tool_calls_map.get(self.current_tool_index)
+            if tool_call:
+                # If tool call wasn't started yet (no args), start it now
+                if not tool_call["started"]:
+                    tool_call["started"] = True
+                    chunks.append({
+                        "type": "TOOL_CALL_START",
+                        "toolCallId": tool_call["id"],
+                        "toolName": tool_call["name"],
                         "model": self.model,
                         "timestamp": self.timestamp,
-                        "toolCall": {
-                            "id": tool_call["id"],
-                            "type": "function",
-                            "function": {
-                                "name": tool_call["name"],
-                                "arguments": partial_json  # Incremental JSON
-                            }
-                        },
                         "index": self.current_tool_index
                     })
+                
+                # Parse input and emit TOOL_CALL_END
+                parsed_input = {}
+                if tool_call["input"]:
+                    try:
+                        parsed_input = json.loads(tool_call["input"])
+                    except json.JSONDecodeError:
+                        parsed_input = {}
+                
+                chunks.append({
+                    "type": "TOOL_CALL_END",
+                    "toolCallId": tool_call["id"],
+                    "toolName": tool_call["name"],
+                    "model": self.model,
+                    "timestamp": self.timestamp,
+                    "input": parsed_input
+                })
+            
+            # Emit TEXT_MESSAGE_END if we had text content
+            if self.has_emitted_text_message_start and self.accumulated_content:
+                chunks.append({
+                    "type": "TEXT_MESSAGE_END",
+                    "messageId": self.message_id,
+                    "model": self.model,
+                    "timestamp": self.timestamp
+                })
         
         elif event_type == "message_delta":
             # Message metadata update (includes stop_reason and usage)
@@ -115,14 +243,6 @@ async def convert_anthropic_event(self, event: Any) -> List[Dict[str, Any]]:
             
             stop_reason = self._get_attr(delta, "stop_reason") if delta else None
             if stop_reason:
-                # Map Anthropic stop_reason to TanStack format
-                if stop_reason == "tool_use":
-                    finish_reason = "tool_calls"
-                elif stop_reason == "end_turn":
-                    finish_reason = "stop"
-                else:
-                    finish_reason = stop_reason
-                
                 usage_dict = None
                 if usage:
                     usage_dict = {
@@ -131,23 +251,43 @@ async def convert_anthropic_event(self, event: Any) -> List[Dict[str, Any]]:
                         "totalTokens": self._get_attr(usage, "input_tokens", 0) + self._get_attr(usage, "output_tokens", 0)
                     }
                 
-                self.done_emitted = True
-                chunks.append({
-                    "type": "done",
-                    "id": self.generate_id(),
-                    "model": self.model,
-                    "timestamp": self.timestamp,
-                    "finishReason": finish_reason,
-                    "usage": usage_dict
-                })
+                # Handle max_tokens as error
+                if stop_reason == "max_tokens":
+                    self.run_finished = True
+                    chunks.append({
+                        "type": "RUN_ERROR",
+                        "runId": self.run_id,
+                        "model": self.model,
+                        "timestamp": self.timestamp,
+                        "error": {
+                            "message": "The response was cut off because the maximum token limit was reached.",
+                            "code": "max_tokens"
+                        }
+                    })
+                else:
+                    # Map Anthropic stop_reason to TanStack format
+                    finish_reason = {
+                        "tool_use": "tool_calls",
+                        "end_turn": "stop"
+                    }.get(stop_reason, stop_reason)
+                    
+                    self.run_finished = True
+                    chunks.append({
+                        "type": "RUN_FINISHED",
+                        "runId": self.run_id,
+                        "model": self.model,
+                        "timestamp": self.timestamp,
+                        "finishReason": finish_reason,
+                        "usage": usage_dict
+                    })
         
         elif event_type == "message_stop":
-            # Stream completed - this is a fallback if message_delta didn't emit done
-            if not self.done_emitted:
-                self.done_emitted = True
+            # Stream completed - this is a fallback if message_delta didn't emit RUN_FINISHED
+            if not self.run_finished:
+                self.run_finished = True
                 chunks.append({
-                    "type": "done",
-                    "id": self.generate_id(),
+                    "type": "RUN_FINISHED",
+                    "runId": self.run_id,
                     "model": self.model,
                     "timestamp": self.timestamp,
                     "finishReason": "stop"
@@ -156,9 +296,14 @@ async def convert_anthropic_event(self, event: Any) -> List[Dict[str, Any]]:
         return chunks
     
     async def convert_openai_event(self, event: Any) -> List[Dict[str, Any]]:
-        """Convert OpenAI streaming event to StreamChunk format"""
+        """Convert OpenAI streaming event to AG-UI StreamChunk format"""
         chunks = []
         
+        # Emit RUN_STARTED on first event
+        run_started = self._maybe_emit_run_started()
+        if run_started:
+            chunks.append(run_started)
+        
         # OpenAI events have chunk.choices[0].delta structure
         choice = self._get_attr(event, "choices", [])
         if choice and len(choice) > 0:
@@ -173,40 +318,103 @@ async def convert_openai_event(self, event: Any) -> List[Dict[str, Any]]:
         if delta:
             content = self._get_attr(delta, "content")
             if content:
+                # Emit TEXT_MESSAGE_START on first text content
+                text_start = self._maybe_emit_text_message_start()
+                if text_start:
+                    chunks.append(text_start)
+                
                 self.accumulated_content += content
                 chunks.append({
-                    "type": "content",
-                    "id": self._get_attr(event, "id", self.generate_id()),
+                    "type": "TEXT_MESSAGE_CONTENT",
+                    "messageId": self.message_id,
                     "model": self._get_attr(event, "model", self.model),
                     "timestamp": self.timestamp,
                     "delta": content,
-                    "content": self.accumulated_content,
-                    "role": "assistant"
+                    "content": self.accumulated_content
                 })
             
             # Handle tool calls
             tool_calls = self._get_attr(delta, "tool_calls")
             if tool_calls:
                 for tool_call in tool_calls:
-                    chunks.append({
-                        "type": "tool_call",
-                        "id": self._get_attr(event, "id", self.generate_id()),
-                        "model": self._get_attr(event, "model", self.model),
-                        "timestamp": self.timestamp,
-                        "toolCall": {
-                            "id": self._get_attr(tool_call, "id", f"call_{self.timestamp}"),
-                            "type": "function",
-                            "function": {
-                                "name": self._get_attr(self._get_attr(tool_call, "function", {}), "name", ""),
-                                "arguments": self._get_attr(self._get_attr(tool_call, "function", {}), "arguments", "")
-                            }
-                        },
-                        "index": self._get_attr(tool_call, "index", 0)
-                    })
+                    tool_index = self._get_attr(tool_call, "index", len(self.tool_calls_map))
+                    tool_id = self._get_attr(tool_call, "id")
+                    function = self._get_attr(tool_call, "function", {})
+                    tool_name = self._get_attr(function, "name", "")
+                    arguments = self._get_attr(function, "arguments", "")
+                    
+                    # Initialize tool call tracking if new
+                    if tool_index not in self.tool_calls_map:
+                        self.tool_calls_map[tool_index] = {
+                            "id": tool_id or f"call_{self.timestamp}_{tool_index}",
+                            "name": tool_name,
+                            "input": "",
+                            "started": False
+                        }
+                    
+                    tracked = self.tool_calls_map[tool_index]
+                    
+                    # Update tool ID and name if provided
+                    if tool_id:
+                        tracked["id"] = tool_id
+                    if tool_name:
+                        tracked["name"] = tool_name
+                    
+                    # Emit TOOL_CALL_START on first encounter
+                    if not tracked["started"] and (tool_id or tool_name):
+                        tracked["started"] = True
+                        chunks.append({
+                            "type": "TOOL_CALL_START",
+                            "toolCallId": tracked["id"],
+                            "toolName": tracked["name"],
+                            "model": self._get_attr(event, "model", self.model),
+                            "timestamp": self.timestamp,
+                            "index": tool_index
+                        })
+                    
+                    # Accumulate arguments
+                    if arguments:
+                        tracked["input"] += arguments
+                        chunks.append({
+                            "type": "TOOL_CALL_ARGS",
+                            "toolCallId": tracked["id"],
+                            "model": self._get_attr(event, "model", self.model),
+                            "timestamp": self.timestamp,
+                            "delta": arguments,
+                            "args": tracked["input"]
+                        })
         
         # Handle completion
         finish_reason = self._get_attr(choice, "finish_reason")
         if finish_reason:
+            # Emit TOOL_CALL_END for all pending tool calls
+            for tool_index, tool_call in self.tool_calls_map.items():
+                if tool_call["started"]:
+                    parsed_input = {}
+                    if tool_call["input"]:
+                        try:
+                            parsed_input = json.loads(tool_call["input"])
+                        except json.JSONDecodeError:
+                            parsed_input = {}
+                    
+                    chunks.append({
+                        "type": "TOOL_CALL_END",
+                        "toolCallId": tool_call["id"],
+                        "toolName": tool_call["name"],
+                        "model": self._get_attr(event, "model", self.model),
+                        "timestamp": self.timestamp,
+                        "input": parsed_input
+                    })
+            
+            # Emit TEXT_MESSAGE_END if we had text content
+            if self.has_emitted_text_message_start:
+                chunks.append({
+                    "type": "TEXT_MESSAGE_END",
+                    "messageId": self.message_id,
+                    "model": self._get_attr(event, "model", self.model),
+                    "timestamp": self.timestamp
+                })
+            
             usage = self._get_attr(event, "usage")
             usage_dict = None
             if usage:
@@ -216,13 +424,21 @@ async def convert_openai_event(self, event: Any) -> List[Dict[str, Any]]:
                     "totalTokens": self._get_attr(usage, "total_tokens", 0)
                 }
             
-            self.done_emitted = True
+            # Map OpenAI finish reasons
+            mapped_finish_reason = {
+                "stop": "stop",
+                "length": "length",
+                "tool_calls": "tool_calls",
+                "content_filter": "content_filter"
+            }.get(finish_reason, finish_reason)
+            
+            self.run_finished = True
             chunks.append({
-                "type": "done",
-                "id": self._get_attr(event, "id", self.generate_id()),
+                "type": "RUN_FINISHED",
+                "runId": self.run_id,
                 "model": self._get_attr(event, "model", self.model),
                 "timestamp": self.timestamp,
-                "finishReason": finish_reason,
+                "finishReason": mapped_finish_reason,
                 "usage": usage_dict
             })
         
@@ -230,7 +446,7 @@ async def convert_openai_event(self, event: Any) -> List[Dict[str, Any]]:
     
     async def convert_event(self, event: Any) -> List[Dict[str, Any]]:
         """
-        Convert provider streaming event to StreamChunk format.
+        Convert provider streaming event to AG-UI StreamChunk format.
         Automatically detects provider based on event structure.
         """
         if self.provider == "anthropic":
@@ -243,7 +459,7 @@ async def convert_event(self, event: Any) -> List[Dict[str, Any]]:
             
             # Anthropic events have types like "content_block_start", "message_delta"
             # OpenAI events have chunk.choices structure
-            if event_type in ["content_block_start", "content_block_delta", "message_delta", "message_stop"]:
+            if event_type in ["content_block_start", "content_block_delta", "content_block_stop", "message_delta", "message_stop"]:
                 return await self.convert_anthropic_event(event)
             elif self._get_attr(event, "choices") is not None:
                 return await self.convert_openai_event(event)
@@ -251,16 +467,24 @@ async def convert_event(self, event: Any) -> List[Dict[str, Any]]:
                 # Default to Anthropic format
                 return await self.convert_anthropic_event(event)
     
-    async def convert_error(self, error: Exception) -> Dict[str, Any]:
-        """Convert an error to ErrorStreamChunk format"""
-        return {
-            "type": "error",
-            "id": self.generate_id(),
+    async def convert_error(self, error: Exception) -> List[Dict[str, Any]]:
+        """Convert an error to RUN_ERROR StreamChunk format (AG-UI Protocol)"""
+        # Ensure RUN_STARTED was emitted before error
+        chunks = []
+        run_started = self._maybe_emit_run_started()
+        if run_started:
+            chunks.append(run_started)
+        
+        chunks.append({
+            "type": "RUN_ERROR",
+            "runId": self.run_id,
             "model": self.model,
             "timestamp": self.timestamp,
             "error": {
                 "message": str(error),
-                "code": getattr(error, "code", None)
+                "code": getattr(error, "code", None) or type(error).__name__
             }
-        }
+        })
+        
+        return chunks
 
diff --git a/packages/python/tanstack-ai/src/tanstack_ai/sse.py b/packages/python/tanstack-ai/src/tanstack_ai/sse.py
index 7d3e30ee..6efdc02f 100644
--- a/packages/python/tanstack-ai/src/tanstack_ai/sse.py
+++ b/packages/python/tanstack-ai/src/tanstack_ai/sse.py
@@ -1,11 +1,13 @@
 """
 Server-Sent Events (SSE) formatting utilities for TanStack AI
 
-Provides utilities for formatting StreamChunk objects into SSE-compatible
+Provides utilities for formatting AG-UI StreamChunk objects into SSE-compatible
 event stream format for HTTP responses.
 """
 import json
-from typing import Dict, Any, AsyncIterator, Iterator, Union
+import secrets
+import time
+from typing import Dict, Any, AsyncIterator, Iterator, Optional, Union
 
 
 def format_sse_chunk(chunk: Dict[str, Any]) -> str:
@@ -31,21 +33,30 @@ def format_sse_done() -> str:
     return "data: [DONE]\n\n"
 
 
-def format_sse_error(error: Exception) -> str:
+def format_sse_error(
+    error: Exception,
+    run_id: Optional[str] = None,
+    model: Optional[str] = None
+) -> str:
     """
-    Format an error as an SSE error chunk.
+    Format an error as an SSE RUN_ERROR chunk (AG-UI Protocol).
     
     Args:
         error: Exception to format
+        run_id: Optional run ID for correlation
+        model: Optional model name
         
     Returns:
-        SSE-formatted error chunk
+        SSE-formatted RUN_ERROR chunk
     """
     error_chunk = {
-        "type": "error",
+        "type": "RUN_ERROR",
+        "runId": run_id or f"run-{secrets.token_hex(4)}",
+        "model": model,
+        "timestamp": int(time.time() * 1000),
         "error": {
-            "type": type(error).__name__,
-            "message": str(error)
+            "message": str(error),
+            "code": getattr(error, "code", None) or type(error).__name__,
         }
     }
     return format_sse_chunk(error_chunk)
diff --git a/packages/python/tanstack-ai/src/tanstack_ai/tool_manager.py b/packages/python/tanstack-ai/src/tanstack_ai/tool_manager.py
index 07d07d5c..1ff6cac9 100644
--- a/packages/python/tanstack-ai/src/tanstack_ai/tool_manager.py
+++ b/packages/python/tanstack-ai/src/tanstack_ai/tool_manager.py
@@ -10,11 +10,11 @@
 from typing import Any, Dict, List, Optional, Tuple
 
 from .types import (
-    DoneStreamChunk,
-    ModelMessage,
     Tool,
     ToolCall,
-    ToolResultStreamChunk,
+    ToolCallArgsEvent,
+    ToolCallEndEvent,
+    ToolCallStartEvent,
 )
 
 
@@ -23,21 +23,23 @@ class ToolCallManager:
     Manages tool call accumulation and execution for automatic tool execution loops.
 
     Responsibilities:
-    - Accumulates streaming tool call chunks (ID, name, arguments)
+    - Accumulates streaming tool call events (ID, name, arguments)
     - Validates tool calls (filters out incomplete ones)
     - Executes tool `execute` functions with parsed arguments
-    - Emits `tool_result` chunks for client visibility
+    - Emits `TOOL_CALL_END` events for client visibility
     - Returns tool result messages for conversation history
 
     Example:
         >>> manager = ToolCallManager(tools)
         >>> # During streaming, accumulate tool calls
         >>> for chunk in stream:
-        ...     if chunk["type"] == "tool_call":
-        ...         manager.add_tool_call_chunk(chunk)
+        ...     if chunk["type"] == "TOOL_CALL_START":
+        ...         manager.add_tool_call_start_event(chunk)
+        ...     elif chunk["type"] == "TOOL_CALL_ARGS":
+        ...         manager.add_tool_call_args_event(chunk)
         >>> # After stream completes, execute tools
         >>> if manager.has_tool_calls():
-        ...     for chunk in manager.execute_tools(done_chunk):
+        ...     for chunk in manager.execute_tools(finish_event):
         ...         yield chunk
         ...     manager.clear()
     """
@@ -52,38 +54,49 @@ def __init__(self, tools: List[Tool]):
         self.tools = tools
         self._tool_calls_map: Dict[int, ToolCall] = {}
 
-    def add_tool_call_chunk(self, chunk: Dict[str, Any]) -> None:
+    def add_tool_call_start_event(self, event: ToolCallStartEvent) -> None:
         """
-        Add a tool call chunk to the accumulator.
-        Handles streaming tool calls by accumulating arguments.
+        Add a TOOL_CALL_START event to begin tracking a tool call.
 
         Args:
-            chunk: Tool call chunk with toolCall and index
+            event: TOOL_CALL_START event
         """
-        index = chunk["index"]
-        tool_call = chunk["toolCall"]
-        existing = self._tool_calls_map.get(index)
-
-        if not existing:
-            # Only create entry if we have a tool call ID and name
-            if tool_call.get("id") and tool_call.get("function", {}).get("name"):
-                self._tool_calls_map[index] = {
-                    "id": tool_call["id"],
-                    "type": "function",
-                    "function": {
-                        "name": tool_call["function"]["name"],
-                        "arguments": tool_call["function"].get("arguments", ""),
-                    },
-                }
-        else:
-            # Update name if it wasn't set before
-            if tool_call.get("function", {}).get("name") and not existing["function"][
-                "name"
-            ]:
-                existing["function"]["name"] = tool_call["function"]["name"]
-            # Accumulate arguments for streaming tool calls
-            if tool_call.get("function", {}).get("arguments"):
-                existing["function"]["arguments"] += tool_call["function"]["arguments"]
+        index = event.get("index", len(self._tool_calls_map))
+        self._tool_calls_map[index] = {
+            "id": event["toolCallId"],
+            "type": "function",
+            "function": {
+                "name": event["toolName"],
+                "arguments": "",
+            },
+        }
+
+    def add_tool_call_args_event(self, event: ToolCallArgsEvent) -> None:
+        """
+        Add a TOOL_CALL_ARGS event to accumulate arguments.
+
+        Args:
+            event: TOOL_CALL_ARGS event
+        """
+        # Find the tool call by ID
+        for tool_call in self._tool_calls_map.values():
+            if tool_call["id"] == event["toolCallId"]:
+                tool_call["function"]["arguments"] += event.get("delta", "")
+                break
+
+    def complete_tool_call(self, event: ToolCallEndEvent) -> None:
+        """
+        Complete a tool call with its final input.
+        Called when TOOL_CALL_END is received.
+
+        Args:
+            event: TOOL_CALL_END event
+        """
+        for tool_call in self._tool_calls_map.values():
+            if tool_call["id"] == event["toolCallId"]:
+                if event.get("input") is not None:
+                    tool_call["function"]["arguments"] = json.dumps(event["input"])
+                break
 
     def has_tool_calls(self) -> bool:
         """Check if there are any complete tool calls to execute."""
@@ -115,10 +128,12 @@ class ToolResult:
     def __init__(
         self,
         tool_call_id: str,
+        tool_name: str,
         result: Any,
         state: Optional[str] = None,
     ):
         self.tool_call_id = tool_call_id
+        self.tool_name = tool_name
         self.result = result
         self.state = state  # 'output-available' | 'output-error'
 
@@ -211,6 +226,7 @@ async def execute_tool_calls(
             results.append(
                 ToolResult(
                     tool_call["id"],
+                    tool_name,
                     {"error": f"Unknown tool: {tool_name}"},
                     "output-error",
                 )
@@ -242,6 +258,7 @@ async def execute_tool_calls(
                             results.append(
                                 ToolResult(
                                     tool_call["id"],
+                                    tool_name,
                                     client_results[tool_call["id"]],
                                 )
                             )
@@ -259,6 +276,7 @@ async def execute_tool_calls(
                         results.append(
                             ToolResult(
                                 tool_call["id"],
+                                tool_name,
                                 {"error": "User declined tool execution"},
                                 "output-error",
                             )
@@ -279,6 +297,7 @@ async def execute_tool_calls(
                     results.append(
                         ToolResult(
                             tool_call["id"],
+                            tool_name,
                             client_results[tool_call["id"]],
                         )
                     )
@@ -305,11 +324,12 @@ async def execute_tool_calls(
                     # Execute after approval
                     try:
                         result = await _execute_tool(tool, input_data)
-                        results.append(ToolResult(tool_call["id"], result))
+                        results.append(ToolResult(tool_call["id"], tool_name, result))
                     except Exception as e:
                         results.append(
                             ToolResult(
                                 tool_call["id"],
+                                tool_name,
                                 {"error": str(e)},
                                 "output-error",
                             )
@@ -319,6 +339,7 @@ async def execute_tool_calls(
                     results.append(
                         ToolResult(
                             tool_call["id"],
+                            tool_name,
                             {"error": "User declined tool execution"},
                             "output-error",
                         )
@@ -338,11 +359,12 @@ async def execute_tool_calls(
         # CASE 3: Normal server tool - execute immediately
         try:
             result = await _execute_tool(tool, input_data)
-            results.append(ToolResult(tool_call["id"], result))
+            results.append(ToolResult(tool_call["id"], tool_name, result))
         except Exception as e:
             results.append(
                 ToolResult(
                     tool_call["id"],
+                    tool_name,
                     {"error": str(e)},
                     "output-error",
                 )
diff --git a/packages/python/tanstack-ai/src/tanstack_ai/types.py b/packages/python/tanstack-ai/src/tanstack_ai/types.py
index 21ccc701..7a853a10 100644
--- a/packages/python/tanstack-ai/src/tanstack_ai/types.py
+++ b/packages/python/tanstack-ai/src/tanstack_ai/types.py
@@ -84,118 +84,232 @@ class Tool:
 
 
 # ============================================================================
-# Stream Chunk Types
+# AG-UI Protocol Event Types
 # ============================================================================
 
+"""
+AG-UI (Agent-User Interaction) Protocol event types.
+Based on the AG-UI specification for agent-user interaction.
+@see https://docs.ag-ui.com/concepts/events
+"""
 
-StreamChunkType = Literal[
-    "content",
-    "thinking",
-    "tool_call",
-    "tool-input-available",
-    "approval-requested",
-    "tool_result",
-    "done",
-    "error",
+AGUIEventType = Literal[
+    "RUN_STARTED",
+    "RUN_FINISHED",
+    "RUN_ERROR",
+    "TEXT_MESSAGE_START",
+    "TEXT_MESSAGE_CONTENT",
+    "TEXT_MESSAGE_END",
+    "TOOL_CALL_START",
+    "TOOL_CALL_ARGS",
+    "TOOL_CALL_END",
+    "STEP_STARTED",
+    "STEP_FINISHED",
+    "STATE_SNAPSHOT",
+    "STATE_DELTA",
+    "CUSTOM",
 ]
 
+# Stream chunk/event types (AG-UI protocol)
+StreamChunkType = AGUIEventType
 
-class BaseStreamChunk(TypedDict):
-    """Base structure for all stream chunks."""
 
-    type: StreamChunkType
-    id: str
-    model: str
+class UsageInfo(TypedDict, total=False):
+    """Token usage information."""
+
+    promptTokens: int
+    completionTokens: int
+    totalTokens: int
+
+
+class ErrorInfo(TypedDict, total=False):
+    """Error information."""
+
+    message: str
+    code: Optional[str]
+
+
+# ============================================================================
+# AG-UI Event Interfaces
+# ============================================================================
+
+
+class BaseAGUIEvent(TypedDict, total=False):
+    """Base structure for AG-UI events."""
+
+    type: AGUIEventType
     timestamp: int  # Unix timestamp in milliseconds
+    model: Optional[str]
+    rawEvent: Optional[Any]
+
+
+class RunStartedEvent(TypedDict):
+    """Emitted when a run starts. This is the first event in any streaming response."""
+
+    type: Literal["RUN_STARTED"]
+    runId: str
+    timestamp: int
+    model: Optional[str]
+    threadId: Optional[str]
+
 
+class RunFinishedEvent(TypedDict, total=False):
+    """Emitted when a run completes successfully."""
+
+    type: Literal["RUN_FINISHED"]
+    runId: str
+    timestamp: int
+    model: Optional[str]
+    finishReason: Optional[Literal["stop", "length", "content_filter", "tool_calls"]]
+    usage: Optional[UsageInfo]
+
+
+class RunErrorEvent(TypedDict, total=False):
+    """Emitted when an error occurs during a run."""
+
+    type: Literal["RUN_ERROR"]
+    runId: Optional[str]
+    timestamp: int
+    model: Optional[str]
+    error: ErrorInfo
 
-class ContentStreamChunk(BaseStreamChunk):
-    """Emitted when the model generates text content."""
 
-    delta: str  # The incremental content token
-    content: str  # Full accumulated content so far
-    role: Optional[Literal["assistant"]]
+class TextMessageStartEvent(TypedDict):
+    """Emitted when a text message starts."""
 
+    type: Literal["TEXT_MESSAGE_START"]
+    messageId: str
+    timestamp: int
+    model: Optional[str]
+    role: Literal["assistant"]
 
-class ThinkingStreamChunk(BaseStreamChunk):
-    """Emitted when the model exposes its reasoning process."""
 
-    delta: Optional[str]  # The incremental thinking token
-    content: str  # Full accumulated thinking content so far
+class TextMessageContentEvent(TypedDict, total=False):
+    """Emitted when text content is generated (streaming tokens)."""
+
+    type: Literal["TEXT_MESSAGE_CONTENT"]
+    messageId: str
+    timestamp: int
+    model: Optional[str]
+    delta: str
+    content: Optional[str]
 
 
-class ToolCallStreamChunk(BaseStreamChunk):
-    """Emitted when the model decides to call a tool/function."""
+class TextMessageEndEvent(TypedDict):
+    """Emitted when a text message completes."""
 
-    toolCall: ToolCall
-    index: int  # Index of this tool call (for parallel calls)
+    type: Literal["TEXT_MESSAGE_END"]
+    messageId: str
+    timestamp: int
+    model: Optional[str]
 
 
-class ToolInputAvailableStreamChunk(BaseStreamChunk):
-    """Emitted when tool inputs are complete and ready for client-side execution."""
+class ToolCallStartEvent(TypedDict, total=False):
+    """Emitted when a tool call starts."""
 
+    type: Literal["TOOL_CALL_START"]
     toolCallId: str
     toolName: str
-    input: Any  # Parsed tool arguments
+    timestamp: int
+    model: Optional[str]
+    index: Optional[int]
 
 
-class ApprovalRequestedStreamChunk(BaseStreamChunk):
-    """Emitted when a tool requires user approval before execution."""
+class ToolCallArgsEvent(TypedDict, total=False):
+    """Emitted when tool call arguments are streaming."""
 
+    type: Literal["TOOL_CALL_ARGS"]
     toolCallId: str
-    toolName: str
-    input: Any
-    approval: Dict[str, Any]  # Contains 'id' and 'needsApproval'
+    timestamp: int
+    model: Optional[str]
+    delta: str
+    args: Optional[str]
 
 
-class ToolResultStreamChunk(BaseStreamChunk):
-    """Emitted when a tool execution completes."""
+class ToolCallEndEvent(TypedDict, total=False):
+    """Emitted when a tool call completes."""
 
+    type: Literal["TOOL_CALL_END"]
     toolCallId: str
-    content: str  # Result of the tool execution (JSON stringified)
+    toolName: str
+    timestamp: int
+    model: Optional[str]
+    input: Optional[Any]
+    result: Optional[str]
 
 
-class UsageInfo(TypedDict, total=False):
-    """Token usage information."""
+class StepStartedEvent(TypedDict, total=False):
+    """Emitted when a thinking/reasoning step starts."""
 
-    promptTokens: int
-    completionTokens: int
-    totalTokens: int
+    type: Literal["STEP_STARTED"]
+    stepId: str
+    timestamp: int
+    model: Optional[str]
+    stepType: Optional[str]
 
 
-class DoneStreamChunk(BaseStreamChunk):
-    """Emitted when the stream completes successfully."""
+class StepFinishedEvent(TypedDict, total=False):
+    """Emitted when a thinking/reasoning step finishes."""
 
-    finishReason: Optional[Literal["stop", "length", "content_filter", "tool_calls"]]
-    usage: Optional[UsageInfo]
+    type: Literal["STEP_FINISHED"]
+    stepId: str
+    timestamp: int
+    model: Optional[str]
+    delta: Optional[str]
+    content: Optional[str]
 
 
-class ErrorInfo(TypedDict, total=False):
-    """Error information."""
+class StateSnapshotEvent(TypedDict):
+    """Emitted to provide a full state snapshot."""
 
-    message: str
-    code: Optional[str]
+    type: Literal["STATE_SNAPSHOT"]
+    timestamp: int
+    model: Optional[str]
+    state: Dict[str, Any]
 
 
-class ErrorStreamChunk(BaseStreamChunk):
-    """Emitted when an error occurs during streaming."""
+class StateDeltaEvent(TypedDict):
+    """Emitted to provide an incremental state update."""
+
+    type: Literal["STATE_DELTA"]
+    timestamp: int
+    model: Optional[str]
+    delta: Dict[str, Any]
 
-    error: ErrorInfo
 
+class CustomEvent(TypedDict, total=False):
+    """Custom event for extensibility."""
 
-# Union type for all stream chunks
-StreamChunk = Union[
-    ContentStreamChunk,
-    ThinkingStreamChunk,
-    ToolCallStreamChunk,
-    ToolInputAvailableStreamChunk,
-    ApprovalRequestedStreamChunk,
-    ToolResultStreamChunk,
-    DoneStreamChunk,
-    ErrorStreamChunk,
+    type: Literal["CUSTOM"]
+    timestamp: int
+    model: Optional[str]
+    name: str
+    data: Optional[Any]
+
+
+# Union of all AG-UI events
+AGUIEvent = Union[
+    RunStartedEvent,
+    RunFinishedEvent,
+    RunErrorEvent,
+    TextMessageStartEvent,
+    TextMessageContentEvent,
+    TextMessageEndEvent,
+    ToolCallStartEvent,
+    ToolCallArgsEvent,
+    ToolCallEndEvent,
+    StepStartedEvent,
+    StepFinishedEvent,
+    StateSnapshotEvent,
+    StateDeltaEvent,
+    CustomEvent,
 ]
 
 
+# Stream chunks use AG-UI event format
+StreamChunk = AGUIEvent
+
+
 # ============================================================================
 # Agent Loop Types
 # ============================================================================
diff --git a/packages/typescript/ai-anthropic/src/adapters/summarize.ts b/packages/typescript/ai-anthropic/src/adapters/summarize.ts
index 02e08506..958c8661 100644
--- a/packages/typescript/ai-anthropic/src/adapters/summarize.ts
+++ b/packages/typescript/ai-anthropic/src/adapters/summarize.ts
@@ -104,20 +104,19 @@ export class AnthropicSummarizeAdapter<
           const delta = event.delta.text
           accumulatedContent += delta
           yield {
-            type: 'content',
-            id,
+            type: 'TEXT_MESSAGE_CONTENT',
+            messageId: id,
             model,
             timestamp: Date.now(),
             delta,
             content: accumulatedContent,
-            role: 'assistant',
           }
         }
       } else if (event.type === 'message_delta') {
         outputTokens = event.usage.output_tokens
         yield {
-          type: 'done',
-          id,
+          type: 'RUN_FINISHED',
+          runId: id,
           model,
           timestamp: Date.now(),
           finishReason: event.delta.stop_reason as
diff --git a/packages/typescript/ai-anthropic/src/adapters/text.ts b/packages/typescript/ai-anthropic/src/adapters/text.ts
index 744911e9..5b1896b2 100644
--- a/packages/typescript/ai-anthropic/src/adapters/text.ts
+++ b/packages/typescript/ai-anthropic/src/adapters/text.ts
@@ -135,8 +135,7 @@ export class AnthropicTextAdapter<
     } catch (error: unknown) {
       const err = error as Error & { status?: number; code?: string }
       yield {
-        type: 'error',
-        id: generateId(this.name),
+        type: 'RUN_ERROR',
         model: options.model,
         timestamp: Date.now(),
         error: {
@@ -460,12 +459,30 @@ export class AnthropicTextAdapter<
     const timestamp = Date.now()
     const toolCallsMap = new Map<
       number,
-      { id: string; name: string; input: string }
+      { id: string; name: string; input: string; started: boolean }
     >()
     let currentToolIndex = -1
 
+    // AG-UI lifecycle tracking
+    const runId = genId()
+    const messageId = genId()
+    let stepId: string | null = null
+    let hasEmittedRunStarted = false
+    let hasEmittedTextMessageStart = false
+
     try {
       for await (const event of stream) {
+        // Emit RUN_STARTED on first event
+        if (!hasEmittedRunStarted) {
+          hasEmittedRunStarted = true
+          yield {
+            type: 'RUN_STARTED',
+            runId,
+            model,
+            timestamp,
+          }
+        }
+
         if (event.type === 'content_block_start') {
           if (event.content_block.type === 'tool_use') {
             currentToolIndex++
@@ -473,30 +490,51 @@ export class AnthropicTextAdapter<
               id: event.content_block.id,
               name: event.content_block.name,
               input: '',
+              started: false,
             })
           } else if (event.content_block.type === 'thinking') {
             accumulatedThinking = ''
+            // Emit STEP_STARTED for thinking
+            stepId = genId()
+            yield {
+              type: 'STEP_STARTED',
+              stepId,
+              model,
+              timestamp,
+              stepType: 'thinking',
+            }
           }
         } else if (event.type === 'content_block_delta') {
           if (event.delta.type === 'text_delta') {
+            // Emit TEXT_MESSAGE_START on first text content
+            if (!hasEmittedTextMessageStart) {
+              hasEmittedTextMessageStart = true
+              yield {
+                type: 'TEXT_MESSAGE_START',
+                messageId,
+                model,
+                timestamp,
+                role: 'assistant',
+              }
+            }
+
             const delta = event.delta.text
             accumulatedContent += delta
             yield {
-              type: 'content',
-              id: genId(),
-              model: model,
+              type: 'TEXT_MESSAGE_CONTENT',
+              messageId,
+              model,
               timestamp,
               delta,
               content: accumulatedContent,
-              role: 'assistant',
             }
           } else if (event.delta.type === 'thinking_delta') {
             const delta = event.delta.thinking
             accumulatedThinking += delta
             yield {
-              type: 'thinking',
-              id: genId(),
-              model: model,
+              type: 'STEP_FINISHED',
+              stepId: stepId || genId(),
+              model,
               timestamp,
               delta,
               content: accumulatedThinking,
@@ -504,49 +542,79 @@ export class AnthropicTextAdapter<
           } else if (event.delta.type === 'input_json_delta') {
             const existing = toolCallsMap.get(currentToolIndex)
             if (existing) {
+              // Emit TOOL_CALL_START on first args delta
+              if (!existing.started) {
+                existing.started = true
+                yield {
+                  type: 'TOOL_CALL_START',
+                  toolCallId: existing.id,
+                  toolName: existing.name,
+                  model,
+                  timestamp,
+                  index: currentToolIndex,
+                }
+              }
+
               existing.input += event.delta.partial_json
 
               yield {
-                type: 'tool_call',
-                id: genId(),
-                model: model,
+                type: 'TOOL_CALL_ARGS',
+                toolCallId: existing.id,
+                model,
                 timestamp,
-                toolCall: {
-                  id: existing.id,
-                  type: 'function',
-                  function: {
-                    name: existing.name,
-                    arguments: event.delta.partial_json,
-                  },
-                },
-                index: currentToolIndex,
+                delta: event.delta.partial_json,
+                args: existing.input,
               }
             }
           }
         } else if (event.type === 'content_block_stop') {
           const existing = toolCallsMap.get(currentToolIndex)
-          if (existing && existing.input === '') {
+          if (existing) {
+            // If tool call wasn't started yet (no args), start it now
+            if (!existing.started) {
+              existing.started = true
+              yield {
+                type: 'TOOL_CALL_START',
+                toolCallId: existing.id,
+                toolName: existing.name,
+                model,
+                timestamp,
+                index: currentToolIndex,
+              }
+            }
+
+            // Emit TOOL_CALL_END
+            let parsedInput: unknown = {}
+            try {
+              parsedInput = existing.input ? JSON.parse(existing.input) : {}
+            } catch {
+              parsedInput = {}
+            }
+
+            yield {
+              type: 'TOOL_CALL_END',
+              toolCallId: existing.id,
+              toolName: existing.name,
+              model,
+              timestamp,
+              input: parsedInput,
+            }
+          }
+
+          // Emit TEXT_MESSAGE_END if we had text content
+          if (hasEmittedTextMessageStart && accumulatedContent) {
             yield {
-              type: 'tool_call',
-              id: genId(),
-              model: model,
+              type: 'TEXT_MESSAGE_END',
+              messageId,
+              model,
               timestamp,
-              toolCall: {
-                id: existing.id,
-                type: 'function',
-                function: {
-                  name: existing.name,
-                  arguments: '{}',
-                },
-              },
-              index: currentToolIndex,
             }
           }
         } else if (event.type === 'message_stop') {
           yield {
-            type: 'done',
-            id: genId(),
-            model: model,
+            type: 'RUN_FINISHED',
+            runId,
+            model,
             timestamp,
             finishReason: 'stop',
           }
@@ -555,9 +623,9 @@ export class AnthropicTextAdapter<
             switch (event.delta.stop_reason) {
               case 'tool_use': {
                 yield {
-                  type: 'done',
-                  id: genId(),
-                  model: model,
+                  type: 'RUN_FINISHED',
+                  runId,
+                  model,
                   timestamp,
                   finishReason: 'tool_calls',
                   usage: {
@@ -572,9 +640,9 @@ export class AnthropicTextAdapter<
               }
               case 'max_tokens': {
                 yield {
-                  type: 'error',
-                  id: genId(),
-                  model: model,
+                  type: 'RUN_ERROR',
+                  runId,
+                  model,
                   timestamp,
                   error: {
                     message:
@@ -586,9 +654,9 @@ export class AnthropicTextAdapter<
               }
               default: {
                 yield {
-                  type: 'done',
-                  id: genId(),
-                  model: model,
+                  type: 'RUN_FINISHED',
+                  runId,
+                  model,
                   timestamp,
                   finishReason: 'stop',
                   usage: {
@@ -608,9 +676,9 @@ export class AnthropicTextAdapter<
       const err = error as Error & { status?: number; code?: string }
 
       yield {
-        type: 'error',
-        id: genId(),
-        model: model,
+        type: 'RUN_ERROR',
+        runId,
+        model,
         timestamp,
         error: {
           message: err.message || 'Unknown error occurred',
diff --git a/packages/typescript/ai-client/src/index.ts b/packages/typescript/ai-client/src/index.ts
index 5bc664c0..3f0a8ee5 100644
--- a/packages/typescript/ai-client/src/index.ts
+++ b/packages/typescript/ai-client/src/index.ts
@@ -51,7 +51,6 @@ export {
   defaultJSONParser,
   type ChunkStrategy,
   type StreamProcessorOptions,
-  type StreamProcessorHandlers,
   type StreamProcessorEvents,
   type InternalToolCallState,
   type ToolCallState,
diff --git a/packages/typescript/ai-client/tests/chat-client-abort.test.ts b/packages/typescript/ai-client/tests/chat-client-abort.test.ts
index 3b77bedd..2adffb1c 100644
--- a/packages/typescript/ai-client/tests/chat-client-abort.test.ts
+++ b/packages/typescript/ai-client/tests/chat-client-abort.test.ts
@@ -15,28 +15,26 @@ describe('ChatClient - Abort Signal Handling', () => {
       async *connect(_messages, _data, abortSignal) {
         receivedAbortSignal = abortSignal
 
-        // Simulate streaming chunks
+        // Simulate streaming chunks (AG-UI format)
         yield {
-          type: 'content',
-          id: '1',
+          type: 'TEXT_MESSAGE_CONTENT',
+          messageId: '1',
           model: 'test',
           timestamp: Date.now(),
           delta: 'Hello',
           content: 'Hello',
-          role: 'assistant',
         }
         yield {
-          type: 'content',
-          id: '1',
+          type: 'TEXT_MESSAGE_CONTENT',
+          messageId: '1',
           model: 'test',
           timestamp: Date.now(),
           delta: ' World',
           content: 'Hello World',
-          role: 'assistant',
         }
         yield {
-          type: 'done',
-          id: '1',
+          type: 'RUN_FINISHED',
+          runId: 'run-1',
           model: 'test',
           timestamp: Date.now(),
           finishReason: 'stop',
@@ -81,24 +79,22 @@ describe('ChatClient - Abort Signal Handling', () => {
 
         try {
           yield {
-            type: 'content',
-            id: '1',
+            type: 'TEXT_MESSAGE_CONTENT',
+            messageId: '1',
             model: 'test',
             timestamp: Date.now(),
             delta: 'Hello',
             content: 'Hello',
-            role: 'assistant',
           }
           // Simulate long-running stream
           await new Promise((resolve) => setTimeout(resolve, 100))
           yield {
-            type: 'content',
-            id: '1',
+            type: 'TEXT_MESSAGE_CONTENT',
+            messageId: '1',
             model: 'test',
             timestamp: Date.now(),
             delta: ' World',
             content: 'Hello World',
-            role: 'assistant',
           }
         } catch (err) {
           // Abort errors are expected
@@ -138,13 +134,12 @@ describe('ChatClient - Abort Signal Handling', () => {
       // eslint-disable-next-line @typescript-eslint/require-await
       async *connect(_messages, _data, abortSignal) {
         yield {
-          type: 'content',
-          id: '1',
+          type: 'TEXT_MESSAGE_CONTENT',
+          messageId: '1',
           model: 'test',
           timestamp: Date.now(),
           delta: 'Hello',
           content: 'Hello',
-          role: 'assistant',
         }
         yieldedChunks++
 
@@ -153,13 +148,12 @@ describe('ChatClient - Abort Signal Handling', () => {
         }
 
         yield {
-          type: 'content',
-          id: '1',
+          type: 'TEXT_MESSAGE_CONTENT',
+          messageId: '1',
           model: 'test',
           timestamp: Date.now(),
           delta: ' World',
           content: 'Hello World',
-          role: 'assistant',
         }
         yieldedChunks++
       },
@@ -197,13 +191,12 @@ describe('ChatClient - Abort Signal Handling', () => {
       // eslint-disable-next-line @typescript-eslint/require-await
       async *connect(_messages, _data, abortSignal) {
         yield {
-          type: 'content',
-          id: '1',
+          type: 'TEXT_MESSAGE_CONTENT',
+          messageId: '1',
           model: 'test',
           timestamp: Date.now(),
           delta: 'Hello',
           content: 'Hello',
-          role: 'assistant',
         }
 
         if (abortSignal?.aborted) {
@@ -238,13 +231,12 @@ describe('ChatClient - Abort Signal Handling', () => {
     const adapterWithAbort: ConnectionAdapter = {
       async *connect(_messages, _data, _abortSignal) {
         yield {
-          type: 'content',
-          id: '1',
+          type: 'TEXT_MESSAGE_CONTENT',
+          messageId: '1',
           model: 'test',
           timestamp: Date.now(),
           delta: 'Hello',
           content: 'Hello',
-          role: 'assistant',
         }
         await new Promise((resolve) => setTimeout(resolve, 50))
       },
@@ -281,8 +273,8 @@ describe('ChatClient - Abort Signal Handling', () => {
           abortSignals.push(abortSignal)
         }
         yield {
-          type: 'done',
-          id: '1',
+          type: 'RUN_FINISHED',
+          runId: 'run-1',
           model: 'test',
           timestamp: Date.now(),
           finishReason: 'stop',
diff --git a/packages/typescript/ai-client/tests/connection-adapters.test.ts b/packages/typescript/ai-client/tests/connection-adapters.test.ts
index cfce39cd..b25b76b3 100644
--- a/packages/typescript/ai-client/tests/connection-adapters.test.ts
+++ b/packages/typescript/ai-client/tests/connection-adapters.test.ts
@@ -30,7 +30,7 @@ describe('connection-adapters', () => {
           .mockResolvedValueOnce({
             done: false,
             value: new TextEncoder().encode(
-              'data: {"type":"content","id":"1","model":"test","timestamp":123,"delta":"Hello","content":"Hello","role":"assistant"}\n\n',
+              'data: {"type":"TEXT_MESSAGE_CONTENT","messageId":"msg-1","model":"test","timestamp":123,"delta":"Hello","content":"Hello"}\n\n',
             ),
           })
           .mockResolvedValueOnce({ done: true, value: undefined }),
@@ -57,7 +57,8 @@ describe('connection-adapters', () => {
 
       expect(chunks).toHaveLength(1)
       expect(chunks[0]).toMatchObject({
-        type: 'content',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         delta: 'Hello',
       })
     })
@@ -69,7 +70,7 @@ describe('connection-adapters', () => {
           .mockResolvedValueOnce({
             done: false,
             value: new TextEncoder().encode(
-              '{"type":"content","id":"1","model":"test","timestamp":123,"delta":"Hello","content":"Hello","role":"assistant"}\n',
+              '{"type":"TEXT_MESSAGE_CONTENT","messageId":"msg-1","model":"test","timestamp":123,"delta":"Hello","content":"Hello"}\n',
             ),
           })
           .mockResolvedValueOnce({ done: true, value: undefined }),
@@ -353,7 +354,7 @@ describe('connection-adapters', () => {
           .mockResolvedValueOnce({
             done: false,
             value: new TextEncoder().encode(
-              '{"type":"content","id":"1","model":"test","timestamp":123,"delta":"Hello","content":"Hello","role":"assistant"}\n',
+              '{"type":"TEXT_MESSAGE_CONTENT","messageId":"msg-1","model":"test","timestamp":123,"delta":"Hello","content":"Hello"}\n',
             ),
           })
           .mockResolvedValueOnce({ done: true, value: undefined }),
@@ -473,13 +474,12 @@ describe('connection-adapters', () => {
     it('should delegate to stream factory', async () => {
       const streamFactory = vi.fn().mockImplementation(function* () {
         yield {
-          type: 'content',
-          id: '1',
+          type: 'TEXT_MESSAGE_CONTENT',
+          messageId: 'msg-1',
           model: 'test',
           timestamp: Date.now(),
           delta: 'Hello',
           content: 'Hello',
-          role: 'assistant',
         }
       })
 
@@ -499,8 +499,8 @@ describe('connection-adapters', () => {
     it('should pass data to stream factory', async () => {
       const streamFactory = vi.fn().mockImplementation(function* () {
         yield {
-          type: 'done',
-          id: '1',
+          type: 'RUN_FINISHED',
+          runId: 'run-1',
           model: 'test',
           timestamp: Date.now(),
           finishReason: 'stop',
diff --git a/packages/typescript/ai-client/tests/test-utils.ts b/packages/typescript/ai-client/tests/test-utils.ts
index 6810b91f..9d0b3d36 100644
--- a/packages/typescript/ai-client/tests/test-utils.ts
+++ b/packages/typescript/ai-client/tests/test-utils.ts
@@ -47,8 +47,8 @@ interface MockConnectionAdapterOptions {
  * ```typescript
  * const adapter = createMockConnectionAdapter({
  *   chunks: [
- *     { type: "content", id: "1", model: "test", timestamp: Date.now(), delta: "Hello", content: "Hello", role: "assistant" },
- *     { type: "done", id: "1", model: "test", timestamp: Date.now(), finishReason: "stop" }
+ *     { type: "TEXT_MESSAGE_CONTENT", messageId: "1", model: "test", timestamp: Date.now(), delta: "Hello", content: "Hello" },
+ *     { type: "RUN_FINISHED", runId: "run-1", model: "test", timestamp: Date.now(), finishReason: "stop" }
  *   ]
  * });
  * ```
@@ -108,7 +108,7 @@ export function createMockConnectionAdapter(
 }
 
 /**
- * Helper to create simple text content chunks
+ * Helper to create simple text content chunks (AG-UI format)
  */
 export function createTextChunks(
   text: string,
@@ -117,34 +117,34 @@ export function createTextChunks(
 ): Array<StreamChunk> {
   const chunks: Array<StreamChunk> = []
   let accumulated = ''
+  const runId = `run-${messageId}`
 
   for (const chunk of text) {
     accumulated += chunk
     chunks.push({
-      type: 'content',
-      id: messageId,
+      type: 'TEXT_MESSAGE_CONTENT',
+      messageId,
       model,
       timestamp: Date.now(),
       delta: chunk,
       content: accumulated,
-      role: 'assistant',
-    } as StreamChunk)
+    })
   }
 
   chunks.push({
-    type: 'done',
-    id: messageId,
+    type: 'RUN_FINISHED',
+    runId,
     model,
     timestamp: Date.now(),
     finishReason: 'stop',
-  } as StreamChunk)
+  })
 
   return chunks
 }
 
 /**
- * Helper to create tool call chunks (in adapter format)
- * Optionally includes tool-input-available chunks to trigger onToolInputAvailable
+ * Helper to create tool call chunks (AG-UI format)
+ * Optionally includes tool-input-available chunks to trigger onToolCall
  */
 export function createToolCallChunks(
   toolCalls: Array<{ id: string; name: string; arguments: string }>,
@@ -153,59 +153,66 @@ export function createToolCallChunks(
   includeToolInputAvailable: boolean = true,
 ): Array<StreamChunk> {
   const chunks: Array<StreamChunk> = []
+  const runId = `run-${messageId}`
 
   for (let i = 0; i < toolCalls.length; i++) {
-    const toolCall = toolCalls[i]
+    const toolCall = toolCalls[i]!
+
+    // TOOL_CALL_START event
     chunks.push({
-      type: 'tool_call',
-      id: messageId,
+      type: 'TOOL_CALL_START',
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
       model,
       timestamp: Date.now(),
       index: i,
-      toolCall: {
-        id: toolCall?.id,
-        type: 'function',
-        function: {
-          name: toolCall?.name,
-          arguments: toolCall?.arguments,
-        },
-      },
-    } as StreamChunk)
+    })
+
+    // TOOL_CALL_ARGS event
+    chunks.push({
+      type: 'TOOL_CALL_ARGS',
+      toolCallId: toolCall.id,
+      model,
+      timestamp: Date.now(),
+      delta: toolCall.arguments,
+    })
 
-    // Add tool-input-available chunk if requested
+    // Add tool-input-available CUSTOM chunk if requested
     if (includeToolInputAvailable) {
       let parsedInput: any
       try {
-        parsedInput = JSON.parse(toolCall?.arguments ?? '')
+        parsedInput = JSON.parse(toolCall.arguments)
       } catch {
-        parsedInput = toolCall?.arguments
+        parsedInput = toolCall.arguments
       }
 
       chunks.push({
-        type: 'tool-input-available',
-        id: messageId,
+        type: 'CUSTOM',
         model,
         timestamp: Date.now(),
-        toolCallId: toolCall?.id,
-        toolName: toolCall?.name,
-        input: parsedInput,
-      } as StreamChunk)
+        name: 'tool-input-available',
+        data: {
+          toolCallId: toolCall.id,
+          toolName: toolCall.name,
+          input: parsedInput,
+        },
+      })
     }
   }
 
   chunks.push({
-    type: 'done',
-    id: messageId,
+    type: 'RUN_FINISHED',
+    runId,
     model,
     timestamp: Date.now(),
-    finishReason: 'stop',
-  } as StreamChunk)
+    finishReason: 'tool_calls',
+  })
 
   return chunks
 }
 
 /**
- * Helper to create thinking chunks
+ * Helper to create thinking chunks (AG-UI format using STEP_FINISHED for thinking)
  */
 export function createThinkingChunks(
   thinkingContent: string,
@@ -215,18 +222,20 @@ export function createThinkingChunks(
 ): Array<StreamChunk> {
   const chunks: Array<StreamChunk> = []
   let accumulatedThinking = ''
+  const runId = `run-${messageId}`
+  const stepId = `step-${messageId}`
 
-  // Add thinking chunks
+  // Add thinking chunks via STEP_FINISHED events
   for (const chunk of thinkingContent) {
     accumulatedThinking += chunk
     chunks.push({
-      type: 'thinking',
-      id: messageId,
+      type: 'STEP_FINISHED',
+      stepId,
       model,
       timestamp: Date.now(),
       delta: chunk,
       content: accumulatedThinking,
-    } as StreamChunk)
+    })
   }
 
   // Optionally add text content after thinking
@@ -235,24 +244,23 @@ export function createThinkingChunks(
     for (const chunk of textContent) {
       accumulatedText += chunk
       chunks.push({
-        type: 'content',
-        id: messageId,
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId,
         model,
         timestamp: Date.now(),
         delta: chunk,
         content: accumulatedText,
-        role: 'assistant',
-      } as StreamChunk)
+      })
     }
   }
 
   chunks.push({
-    type: 'done',
-    id: messageId,
+    type: 'RUN_FINISHED',
+    runId,
     model,
     timestamp: Date.now(),
     finishReason: 'stop',
-  } as StreamChunk)
+  })
 
   return chunks
 }
diff --git a/packages/typescript/ai-gemini/src/adapters/summarize.ts b/packages/typescript/ai-gemini/src/adapters/summarize.ts
index 1c717e63..40a18bb7 100644
--- a/packages/typescript/ai-gemini/src/adapters/summarize.ts
+++ b/packages/typescript/ai-gemini/src/adapters/summarize.ts
@@ -164,13 +164,12 @@ export class GeminiSummarizeAdapter<
           if (part.text) {
             accumulatedContent += part.text
             yield {
-              type: 'content',
-              id,
+              type: 'TEXT_MESSAGE_CONTENT',
+              messageId: id,
               model,
               timestamp: Date.now(),
               delta: part.text,
               content: accumulatedContent,
-              role: 'assistant',
             }
           }
         }
@@ -184,8 +183,8 @@ export class GeminiSummarizeAdapter<
         finishReason === FinishReason.SAFETY
       ) {
         yield {
-          type: 'done',
-          id,
+          type: 'RUN_FINISHED',
+          runId: id,
           model,
           timestamp: Date.now(),
           finishReason:
diff --git a/packages/typescript/ai-gemini/src/adapters/text.ts b/packages/typescript/ai-gemini/src/adapters/text.ts
index 302409f8..6210dadc 100644
--- a/packages/typescript/ai-gemini/src/adapters/text.ts
+++ b/packages/typescript/ai-gemini/src/adapters/text.ts
@@ -115,8 +115,7 @@ export class GeminiTextAdapter<
     } catch (error) {
       const timestamp = Date.now()
       yield {
-        type: 'error',
-        id: generateId(this.name),
+        type: 'RUN_ERROR',
         model: options.model,
         timestamp,
         error: {
@@ -203,35 +202,78 @@ export class GeminiTextAdapter<
     let accumulatedContent = ''
     const toolCallMap = new Map<
       string,
-      { name: string; args: string; index: number }
+      { name: string; args: string; index: number; started: boolean }
     >()
     let nextToolIndex = 0
 
+    // AG-UI lifecycle tracking
+    const runId = generateId(this.name)
+    const messageId = generateId(this.name)
+    let stepId: string | null = null
+    let hasEmittedRunStarted = false
+    let hasEmittedTextMessageStart = false
+    let hasEmittedStepStarted = false
+
     for await (const chunk of result) {
+      // Emit RUN_STARTED on first chunk
+      if (!hasEmittedRunStarted) {
+        hasEmittedRunStarted = true
+        yield {
+          type: 'RUN_STARTED',
+          runId,
+          model,
+          timestamp,
+        }
+      }
+
       if (chunk.candidates?.[0]?.content?.parts) {
         const parts = chunk.candidates[0].content.parts
 
         for (const part of parts) {
           if (part.text) {
             if (part.thought) {
+              // Emit STEP_STARTED on first thinking content
+              if (!hasEmittedStepStarted) {
+                hasEmittedStepStarted = true
+                stepId = generateId(this.name)
+                yield {
+                  type: 'STEP_STARTED',
+                  stepId,
+                  model,
+                  timestamp,
+                  stepType: 'thinking',
+                }
+              }
+
               yield {
-                type: 'thinking',
-                content: part.text,
-                delta: part.text,
-                id: generateId(this.name),
+                type: 'STEP_FINISHED',
+                stepId: stepId || generateId(this.name),
                 model,
                 timestamp,
+                delta: part.text,
+                content: part.text,
               }
             } else {
+              // Emit TEXT_MESSAGE_START on first text content
+              if (!hasEmittedTextMessageStart) {
+                hasEmittedTextMessageStart = true
+                yield {
+                  type: 'TEXT_MESSAGE_START',
+                  messageId,
+                  model,
+                  timestamp,
+                  role: 'assistant',
+                }
+              }
+
               accumulatedContent += part.text
               yield {
-                type: 'content',
-                id: generateId(this.name),
+                type: 'TEXT_MESSAGE_CONTENT',
+                messageId,
                 model,
                 timestamp,
                 delta: part.text,
                 content: accumulatedContent,
-                role: 'assistant',
               }
             }
           }
@@ -252,6 +294,7 @@ export class GeminiTextAdapter<
                     ? functionArgs
                     : JSON.stringify(functionArgs),
                 index: nextToolIndex++,
+                started: false,
               }
               toolCallMap.set(toolCallId, toolCallData)
             } else {
@@ -271,33 +314,51 @@ export class GeminiTextAdapter<
               }
             }
 
+            // Emit TOOL_CALL_START if not already started
+            if (!toolCallData.started) {
+              toolCallData.started = true
+              yield {
+                type: 'TOOL_CALL_START',
+                toolCallId,
+                toolName: toolCallData.name,
+                model,
+                timestamp,
+                index: toolCallData.index,
+              }
+            }
+
+            // Emit TOOL_CALL_ARGS
             yield {
-              type: 'tool_call',
-              id: generateId(this.name),
+              type: 'TOOL_CALL_ARGS',
+              toolCallId,
               model,
               timestamp,
-              toolCall: {
-                id: toolCallId,
-                type: 'function',
-                function: {
-                  name: toolCallData.name,
-                  arguments: toolCallData.args,
-                },
-              },
-              index: toolCallData.index,
+              delta: toolCallData.args,
+              args: toolCallData.args,
             }
           }
         }
       } else if (chunk.data) {
+        // Emit TEXT_MESSAGE_START on first text content
+        if (!hasEmittedTextMessageStart) {
+          hasEmittedTextMessageStart = true
+          yield {
+            type: 'TEXT_MESSAGE_START',
+            messageId,
+            model,
+            timestamp,
+            role: 'assistant',
+          }
+        }
+
         accumulatedContent += chunk.data
         yield {
-          type: 'content',
-          id: generateId(this.name),
+          type: 'TEXT_MESSAGE_CONTENT',
+          messageId,
           model,
           timestamp,
           delta: chunk.data,
           content: accumulatedContent,
-          role: 'assistant',
         }
       }
 
@@ -314,53 +375,98 @@ export class GeminiTextAdapter<
                   `${functionCall.name}_${Date.now()}_${nextToolIndex}`
                 const functionArgs = functionCall.args || {}
 
+                const argsString =
+                  typeof functionArgs === 'string'
+                    ? functionArgs
+                    : JSON.stringify(functionArgs)
+
                 toolCallMap.set(toolCallId, {
                   name: functionCall.name || '',
-                  args:
-                    typeof functionArgs === 'string'
-                      ? functionArgs
-                      : JSON.stringify(functionArgs),
+                  args: argsString,
                   index: nextToolIndex++,
+                  started: true,
                 })
 
+                // Emit TOOL_CALL_START
                 yield {
-                  type: 'tool_call',
-                  id: generateId(this.name),
+                  type: 'TOOL_CALL_START',
+                  toolCallId,
+                  toolName: functionCall.name || '',
                   model,
                   timestamp,
-                  toolCall: {
-                    id: toolCallId,
-                    type: 'function',
-                    function: {
-                      name: functionCall.name || '',
-                      arguments:
-                        typeof functionArgs === 'string'
-                          ? functionArgs
-                          : JSON.stringify(functionArgs),
-                    },
-                  },
                   index: nextToolIndex - 1,
                 }
+
+                // Emit TOOL_CALL_END with parsed input
+                let parsedInput: unknown = {}
+                try {
+                  parsedInput =
+                    typeof functionArgs === 'string'
+                      ? JSON.parse(functionArgs)
+                      : functionArgs
+                } catch {
+                  parsedInput = {}
+                }
+
+                yield {
+                  type: 'TOOL_CALL_END',
+                  toolCallId,
+                  toolName: functionCall.name || '',
+                  model,
+                  timestamp,
+                  input: parsedInput,
+                }
               }
             }
           }
         }
+
+        // Emit TOOL_CALL_END for all tracked tool calls
+        for (const [toolCallId, toolCallData] of toolCallMap.entries()) {
+          let parsedInput: unknown = {}
+          try {
+            parsedInput = JSON.parse(toolCallData.args)
+          } catch {
+            parsedInput = {}
+          }
+
+          yield {
+            type: 'TOOL_CALL_END',
+            toolCallId,
+            toolName: toolCallData.name,
+            model,
+            timestamp,
+            input: parsedInput,
+          }
+        }
+
         if (finishReason === FinishReason.MAX_TOKENS) {
           yield {
-            type: 'error',
-            id: generateId(this.name),
+            type: 'RUN_ERROR',
+            runId,
             model,
             timestamp,
             error: {
               message:
                 'The response was cut off because the maximum token limit was reached.',
+              code: 'max_tokens',
             },
           }
         }
 
+        // Emit TEXT_MESSAGE_END if we had text content
+        if (hasEmittedTextMessageStart) {
+          yield {
+            type: 'TEXT_MESSAGE_END',
+            messageId,
+            model,
+            timestamp,
+          }
+        }
+
         yield {
-          type: 'done',
-          id: generateId(this.name),
+          type: 'RUN_FINISHED',
+          runId,
           model,
           timestamp,
           finishReason: toolCallMap.size > 0 ? 'tool_calls' : 'stop',
diff --git a/packages/typescript/ai-gemini/tests/gemini-adapter.test.ts b/packages/typescript/ai-gemini/tests/gemini-adapter.test.ts
index 1f000171..9add4bdc 100644
--- a/packages/typescript/ai-gemini/tests/gemini-adapter.test.ts
+++ b/packages/typescript/ai-gemini/tests/gemini-adapter.test.ts
@@ -297,18 +297,30 @@ describe('GeminiAdapter through AI', () => {
     expect(mocks.generateContentStreamSpy).toHaveBeenCalledTimes(1)
     const [streamPayload] = mocks.generateContentStreamSpy.mock.calls[0]
     expect(streamPayload.config?.topK).toBe(3)
+
+    // AG-UI events: RUN_STARTED, TEXT_MESSAGE_START, TEXT_MESSAGE_CONTENT..., TEXT_MESSAGE_END, RUN_FINISHED
     expect(received[0]).toMatchObject({
-      type: 'content',
+      type: 'RUN_STARTED',
+    })
+    expect(received[1]).toMatchObject({
+      type: 'TEXT_MESSAGE_START',
+      role: 'assistant',
+    })
+    expect(received[2]).toMatchObject({
+      type: 'TEXT_MESSAGE_CONTENT',
       delta: 'Partly ',
       content: 'Partly ',
     })
-    expect(received[1]).toMatchObject({
-      type: 'content',
+    expect(received[3]).toMatchObject({
+      type: 'TEXT_MESSAGE_CONTENT',
       delta: 'cloudy',
       content: 'Partly cloudy',
     })
+    expect(received[4]).toMatchObject({
+      type: 'TEXT_MESSAGE_END',
+    })
     expect(received.at(-1)).toMatchObject({
-      type: 'done',
+      type: 'RUN_FINISHED',
       finishReason: 'stop',
       usage: {
         promptTokens: 4,
diff --git a/packages/typescript/ai-grok/src/adapters/summarize.ts b/packages/typescript/ai-grok/src/adapters/summarize.ts
index 5cd273f0..e9de0b66 100644
--- a/packages/typescript/ai-grok/src/adapters/summarize.ts
+++ b/packages/typescript/ai-grok/src/adapters/summarize.ts
@@ -51,7 +51,7 @@ export class GrokSummarizeAdapter<
 
     // Use the text adapter's streaming and collect the result
     let summary = ''
-    let id = ''
+    const id = ''
     let model = options.model
     let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
 
@@ -62,13 +62,20 @@ export class GrokSummarizeAdapter<
       maxTokens: options.maxLength,
       temperature: 0.3,
     })) {
-      if (chunk.type === 'content') {
-        summary = chunk.content
-        id = chunk.id
-        model = chunk.model
+      // AG-UI TEXT_MESSAGE_CONTENT event
+      if (chunk.type === 'TEXT_MESSAGE_CONTENT') {
+        if (chunk.content) {
+          summary = chunk.content
+        } else {
+          summary += chunk.delta
+        }
+        model = chunk.model || model
       }
-      if (chunk.type === 'done' && chunk.usage) {
-        usage = chunk.usage
+      // AG-UI RUN_FINISHED event
+      if (chunk.type === 'RUN_FINISHED') {
+        if (chunk.usage) {
+          usage = chunk.usage
+        }
       }
     }
 
diff --git a/packages/typescript/ai-grok/src/adapters/text.ts b/packages/typescript/ai-grok/src/adapters/text.ts
index bef2ffaf..f8703f7f 100644
--- a/packages/typescript/ai-grok/src/adapters/text.ts
+++ b/packages/typescript/ai-grok/src/adapters/text.ts
@@ -69,6 +69,15 @@ export class GrokTextAdapter<
     options: TextOptions<ResolveProviderOptions<TModel>>,
   ): AsyncIterable<StreamChunk> {
     const requestParams = this.mapTextOptionsToGrok(options)
+    const timestamp = Date.now()
+
+    // AG-UI lifecycle tracking (mutable state object for ESLint compatibility)
+    const aguiState = {
+      runId: generateId(this.name),
+      messageId: generateId(this.name),
+      timestamp,
+      hasEmittedRunStarted: false,
+    }
 
     try {
       const stream = await this.client.chat.completions.create({
@@ -76,14 +85,37 @@ export class GrokTextAdapter<
         stream: true,
       })
 
-      yield* this.processGrokStreamChunks(stream, options)
+      yield* this.processGrokStreamChunks(stream, options, aguiState)
     } catch (error: unknown) {
-      const err = error as Error
+      const err = error as Error & { code?: string }
+
+      // Emit RUN_STARTED if not yet emitted
+      if (!aguiState.hasEmittedRunStarted) {
+        aguiState.hasEmittedRunStarted = true
+        yield {
+          type: 'RUN_STARTED',
+          runId: aguiState.runId,
+          model: options.model,
+          timestamp,
+        }
+      }
+
+      // Emit AG-UI RUN_ERROR
+      yield {
+        type: 'RUN_ERROR',
+        runId: aguiState.runId,
+        model: options.model,
+        timestamp,
+        error: {
+          message: err.message || 'Unknown error',
+          code: err.code,
+        },
+      }
+
       console.error('>>> chatStream: Fatal error during response creation <<<')
       console.error('>>> Error message:', err.message)
       console.error('>>> Error stack:', err.stack)
       console.error('>>> Full error:', err)
-      throw error
     }
   }
 
@@ -157,10 +189,16 @@ export class GrokTextAdapter<
   private async *processGrokStreamChunks(
     stream: AsyncIterable<OpenAI_SDK.Chat.Completions.ChatCompletionChunk>,
     options: TextOptions,
+    aguiState: {
+      runId: string
+      messageId: string
+      timestamp: number
+      hasEmittedRunStarted: boolean
+    },
   ): AsyncIterable<StreamChunk> {
     let accumulatedContent = ''
-    const timestamp = Date.now()
-    let responseId = generateId(this.name)
+    const timestamp = aguiState.timestamp
+    let hasEmittedTextMessageStart = false
 
     // Track tool calls being streamed (arguments come in chunks)
     const toolCallsInProgress = new Map<
@@ -169,31 +207,55 @@ export class GrokTextAdapter<
         id: string
         name: string
         arguments: string
+        started: boolean // Track if TOOL_CALL_START has been emitted
       }
     >()
 
     try {
       for await (const chunk of stream) {
-        responseId = chunk.id || responseId
         const choice = chunk.choices[0]
 
         if (!choice) continue
 
+        // Emit RUN_STARTED on first chunk
+        if (!aguiState.hasEmittedRunStarted) {
+          aguiState.hasEmittedRunStarted = true
+          yield {
+            type: 'RUN_STARTED',
+            runId: aguiState.runId,
+            model: chunk.model || options.model,
+            timestamp,
+          }
+        }
+
         const delta = choice.delta
         const deltaContent = delta.content
         const deltaToolCalls = delta.tool_calls
 
         // Handle content delta
         if (deltaContent) {
+          // Emit TEXT_MESSAGE_START on first text content
+          if (!hasEmittedTextMessageStart) {
+            hasEmittedTextMessageStart = true
+            yield {
+              type: 'TEXT_MESSAGE_START',
+              messageId: aguiState.messageId,
+              model: chunk.model || options.model,
+              timestamp,
+              role: 'assistant',
+            }
+          }
+
           accumulatedContent += deltaContent
+
+          // Emit AG-UI TEXT_MESSAGE_CONTENT
           yield {
-            type: 'content',
-            id: responseId,
+            type: 'TEXT_MESSAGE_CONTENT',
+            messageId: aguiState.messageId,
             model: chunk.model || options.model,
             timestamp,
             delta: deltaContent,
             content: accumulatedContent,
-            role: 'assistant',
           }
         }
 
@@ -208,6 +270,7 @@ export class GrokTextAdapter<
                 id: toolCallDelta.id || '',
                 name: toolCallDelta.function?.name || '',
                 arguments: '',
+                started: false,
               })
             }
 
@@ -223,6 +286,30 @@ export class GrokTextAdapter<
             if (toolCallDelta.function?.arguments) {
               toolCall.arguments += toolCallDelta.function.arguments
             }
+
+            // Emit TOOL_CALL_START when we have id and name
+            if (toolCall.id && toolCall.name && !toolCall.started) {
+              toolCall.started = true
+              yield {
+                type: 'TOOL_CALL_START',
+                toolCallId: toolCall.id,
+                toolName: toolCall.name,
+                model: chunk.model || options.model,
+                timestamp,
+                index,
+              }
+            }
+
+            // Emit TOOL_CALL_ARGS for argument deltas
+            if (toolCallDelta.function?.arguments && toolCall.started) {
+              yield {
+                type: 'TOOL_CALL_ARGS',
+                toolCallId: toolCall.id,
+                model: chunk.model || options.model,
+                timestamp,
+                delta: toolCallDelta.function.arguments,
+              }
+            }
           }
         }
 
@@ -233,28 +320,49 @@ export class GrokTextAdapter<
             choice.finish_reason === 'tool_calls' ||
             toolCallsInProgress.size > 0
           ) {
-            for (const [index, toolCall] of toolCallsInProgress) {
+            for (const [, toolCall] of toolCallsInProgress) {
+              // Parse arguments for TOOL_CALL_END
+              let parsedInput: unknown = {}
+              try {
+                parsedInput = toolCall.arguments
+                  ? JSON.parse(toolCall.arguments)
+                  : {}
+              } catch {
+                parsedInput = {}
+              }
+
+              // Emit AG-UI TOOL_CALL_END
               yield {
-                type: 'tool_call',
-                id: responseId,
+                type: 'TOOL_CALL_END',
+                toolCallId: toolCall.id,
+                toolName: toolCall.name,
                 model: chunk.model || options.model,
                 timestamp,
-                index,
-                toolCall: {
-                  id: toolCall.id,
-                  type: 'function',
-                  function: {
-                    name: toolCall.name,
-                    arguments: toolCall.arguments,
-                  },
-                },
+                input: parsedInput,
               }
             }
           }
 
+          const computedFinishReason =
+            choice.finish_reason === 'tool_calls' ||
+            toolCallsInProgress.size > 0
+              ? 'tool_calls'
+              : 'stop'
+
+          // Emit TEXT_MESSAGE_END if we had text content
+          if (hasEmittedTextMessageStart) {
+            yield {
+              type: 'TEXT_MESSAGE_END',
+              messageId: aguiState.messageId,
+              model: chunk.model || options.model,
+              timestamp,
+            }
+          }
+
+          // Emit AG-UI RUN_FINISHED
           yield {
-            type: 'done',
-            id: responseId,
+            type: 'RUN_FINISHED',
+            runId: aguiState.runId,
             model: chunk.model || options.model,
             timestamp,
             usage: chunk.usage
@@ -264,20 +372,18 @@ export class GrokTextAdapter<
                   totalTokens: chunk.usage.total_tokens || 0,
                 }
               : undefined,
-            finishReason:
-              choice.finish_reason === 'tool_calls' ||
-              toolCallsInProgress.size > 0
-                ? 'tool_calls'
-                : 'stop',
+            finishReason: computedFinishReason,
           }
         }
       }
     } catch (error: unknown) {
       const err = error as Error & { code?: string }
       console.log('[Grok Adapter] Stream ended with error:', err.message)
+
+      // Emit AG-UI RUN_ERROR
       yield {
-        type: 'error',
-        id: responseId,
+        type: 'RUN_ERROR',
+        runId: aguiState.runId,
         model: options.model,
         timestamp,
         error: {
diff --git a/packages/typescript/ai-grok/tests/grok-adapter.test.ts b/packages/typescript/ai-grok/tests/grok-adapter.test.ts
index 09373f50..14e3e57c 100644
--- a/packages/typescript/ai-grok/tests/grok-adapter.test.ts
+++ b/packages/typescript/ai-grok/tests/grok-adapter.test.ts
@@ -1,7 +1,59 @@
-import { describe, it, expect, vi, afterEach } from 'vitest'
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest'
 import { createGrokText, grokText } from '../src/adapters/text'
 import { createGrokImage, grokImage } from '../src/adapters/image'
 import { createGrokSummarize, grokSummarize } from '../src/adapters/summarize'
+import type { StreamChunk, Tool } from '@tanstack/ai'
+
+// Declare mockCreate at module level
+let mockCreate: ReturnType<typeof vi.fn>
+
+// Mock the OpenAI SDK
+vi.mock('openai', () => {
+  return {
+    default: class {
+      chat = {
+        completions: {
+          create: (...args: Array<unknown>) => mockCreate(...args),
+        },
+      }
+    },
+  }
+})
+
+// Helper to create async iterable from chunks
+function createAsyncIterable<T>(chunks: Array<T>): AsyncIterable<T> {
+  return {
+    [Symbol.asyncIterator]() {
+      let index = 0
+      return {
+        async next() {
+          if (index < chunks.length) {
+            return { value: chunks[index++]!, done: false }
+          }
+          return { value: undefined as T, done: true }
+        },
+      }
+    },
+  }
+}
+
+// Helper to setup the mock SDK client for streaming responses
+function setupMockSdkClient(
+  streamChunks: Array<Record<string, unknown>>,
+  nonStreamResponse?: Record<string, unknown>,
+) {
+  mockCreate = vi.fn().mockImplementation((params) => {
+    if (params.stream) {
+      return Promise.resolve(createAsyncIterable(streamChunks))
+    }
+    return Promise.resolve(nonStreamResponse)
+  })
+}
+
+const weatherTool: Tool = {
+  name: 'lookup_weather',
+  description: 'Return the forecast for a location',
+}
 
 describe('Grok adapters', () => {
   afterEach(() => {
@@ -97,3 +149,459 @@ describe('Grok adapters', () => {
     })
   })
 })
+
+describe('Grok AG-UI event emission', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.unstubAllEnvs()
+  })
+
+  it('emits RUN_STARTED as the first event', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-123',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: { content: 'Hello' },
+            finish_reason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-123',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: {},
+            finish_reason: 'stop',
+          },
+        ],
+        usage: {
+          prompt_tokens: 5,
+          completion_tokens: 1,
+          total_tokens: 6,
+        },
+      },
+    ]
+
+    setupMockSdkClient(streamChunks)
+    const adapter = createGrokText('grok-3', 'test-api-key')
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'grok-3',
+      messages: [{ role: 'user', content: 'Hello' }],
+    })) {
+      chunks.push(chunk)
+    }
+
+    expect(chunks[0]?.type).toBe('RUN_STARTED')
+    if (chunks[0]?.type === 'RUN_STARTED') {
+      expect(chunks[0].runId).toBeDefined()
+      expect(chunks[0].model).toBe('grok-3')
+    }
+  })
+
+  it('emits TEXT_MESSAGE_START before TEXT_MESSAGE_CONTENT', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-123',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: { content: 'Hello' },
+            finish_reason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-123',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: {},
+            finish_reason: 'stop',
+          },
+        ],
+        usage: {
+          prompt_tokens: 5,
+          completion_tokens: 1,
+          total_tokens: 6,
+        },
+      },
+    ]
+
+    setupMockSdkClient(streamChunks)
+    const adapter = createGrokText('grok-3', 'test-api-key')
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'grok-3',
+      messages: [{ role: 'user', content: 'Hello' }],
+    })) {
+      chunks.push(chunk)
+    }
+
+    const textStartIndex = chunks.findIndex(
+      (c) => c.type === 'TEXT_MESSAGE_START',
+    )
+    const textContentIndex = chunks.findIndex(
+      (c) => c.type === 'TEXT_MESSAGE_CONTENT',
+    )
+
+    expect(textStartIndex).toBeGreaterThan(-1)
+    expect(textContentIndex).toBeGreaterThan(-1)
+    expect(textStartIndex).toBeLessThan(textContentIndex)
+
+    const textStart = chunks[textStartIndex]
+    if (textStart?.type === 'TEXT_MESSAGE_START') {
+      expect(textStart.messageId).toBeDefined()
+      expect(textStart.role).toBe('assistant')
+    }
+  })
+
+  it('emits TEXT_MESSAGE_END and RUN_FINISHED at the end', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-123',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: { content: 'Hello' },
+            finish_reason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-123',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: {},
+            finish_reason: 'stop',
+          },
+        ],
+        usage: {
+          prompt_tokens: 5,
+          completion_tokens: 1,
+          total_tokens: 6,
+        },
+      },
+    ]
+
+    setupMockSdkClient(streamChunks)
+    const adapter = createGrokText('grok-3', 'test-api-key')
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'grok-3',
+      messages: [{ role: 'user', content: 'Hello' }],
+    })) {
+      chunks.push(chunk)
+    }
+
+    const textEndChunk = chunks.find((c) => c.type === 'TEXT_MESSAGE_END')
+    expect(textEndChunk).toBeDefined()
+    if (textEndChunk?.type === 'TEXT_MESSAGE_END') {
+      expect(textEndChunk.messageId).toBeDefined()
+    }
+
+    const runFinishedChunk = chunks.find((c) => c.type === 'RUN_FINISHED')
+    expect(runFinishedChunk).toBeDefined()
+    if (runFinishedChunk?.type === 'RUN_FINISHED') {
+      expect(runFinishedChunk.runId).toBeDefined()
+      expect(runFinishedChunk.finishReason).toBe('stop')
+      expect(runFinishedChunk.usage).toMatchObject({
+        promptTokens: 5,
+        completionTokens: 1,
+        totalTokens: 6,
+      })
+    }
+  })
+
+  it('emits AG-UI tool call events', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-456',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: {
+              tool_calls: [
+                {
+                  index: 0,
+                  id: 'call_abc123',
+                  type: 'function',
+                  function: {
+                    name: 'lookup_weather',
+                    arguments: '{"location":',
+                  },
+                },
+              ],
+            },
+            finish_reason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-456',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: {
+              tool_calls: [
+                {
+                  index: 0,
+                  function: {
+                    arguments: '"Berlin"}',
+                  },
+                },
+              ],
+            },
+            finish_reason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-456',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: {},
+            finish_reason: 'tool_calls',
+          },
+        ],
+        usage: {
+          prompt_tokens: 10,
+          completion_tokens: 5,
+          total_tokens: 15,
+        },
+      },
+    ]
+
+    setupMockSdkClient(streamChunks)
+    const adapter = createGrokText('grok-3', 'test-api-key')
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'grok-3',
+      messages: [{ role: 'user', content: 'Weather in Berlin?' }],
+      tools: [weatherTool],
+    })) {
+      chunks.push(chunk)
+    }
+
+    // Check AG-UI tool events
+    const toolStartChunk = chunks.find((c) => c.type === 'TOOL_CALL_START')
+    expect(toolStartChunk).toBeDefined()
+    if (toolStartChunk?.type === 'TOOL_CALL_START') {
+      expect(toolStartChunk.toolCallId).toBe('call_abc123')
+      expect(toolStartChunk.toolName).toBe('lookup_weather')
+    }
+
+    const toolArgsChunks = chunks.filter((c) => c.type === 'TOOL_CALL_ARGS')
+    expect(toolArgsChunks.length).toBeGreaterThan(0)
+
+    const toolEndChunk = chunks.find((c) => c.type === 'TOOL_CALL_END')
+    expect(toolEndChunk).toBeDefined()
+    if (toolEndChunk?.type === 'TOOL_CALL_END') {
+      expect(toolEndChunk.toolCallId).toBe('call_abc123')
+      expect(toolEndChunk.toolName).toBe('lookup_weather')
+      expect(toolEndChunk.input).toEqual({ location: 'Berlin' })
+    }
+
+    // Check finish reason
+    const runFinishedChunk = chunks.find((c) => c.type === 'RUN_FINISHED')
+    if (runFinishedChunk?.type === 'RUN_FINISHED') {
+      expect(runFinishedChunk.finishReason).toBe('tool_calls')
+    }
+  })
+
+  it('emits RUN_ERROR on stream error', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-123',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: { content: 'Hello' },
+            finish_reason: null,
+          },
+        ],
+      },
+    ]
+
+    // Create an async iterable that throws mid-stream
+    const errorIterable = {
+      [Symbol.asyncIterator]() {
+        let index = 0
+        return {
+          async next() {
+            if (index < streamChunks.length) {
+              return { value: streamChunks[index++]!, done: false }
+            }
+            throw new Error('Stream interrupted')
+          },
+        }
+      },
+    }
+
+    mockCreate = vi.fn().mockResolvedValue(errorIterable)
+
+    const adapter = createGrokText('grok-3', 'test-api-key')
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'grok-3',
+      messages: [{ role: 'user', content: 'Hello' }],
+    })) {
+      chunks.push(chunk)
+    }
+
+    // Should emit RUN_ERROR
+    const runErrorChunk = chunks.find((c) => c.type === 'RUN_ERROR')
+    expect(runErrorChunk).toBeDefined()
+    if (runErrorChunk?.type === 'RUN_ERROR') {
+      expect(runErrorChunk.error.message).toBe('Stream interrupted')
+    }
+  })
+
+  it('emits proper AG-UI event sequence', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-123',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: { content: 'Hello world' },
+            finish_reason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-123',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: {},
+            finish_reason: 'stop',
+          },
+        ],
+        usage: {
+          prompt_tokens: 5,
+          completion_tokens: 2,
+          total_tokens: 7,
+        },
+      },
+    ]
+
+    setupMockSdkClient(streamChunks)
+    const adapter = createGrokText('grok-3', 'test-api-key')
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'grok-3',
+      messages: [{ role: 'user', content: 'Hello' }],
+    })) {
+      chunks.push(chunk)
+    }
+
+    // Verify proper AG-UI event sequence
+    const eventTypes = chunks.map((c) => c.type)
+
+    // Should start with RUN_STARTED
+    expect(eventTypes[0]).toBe('RUN_STARTED')
+
+    // Should have TEXT_MESSAGE_START before TEXT_MESSAGE_CONTENT
+    const textStartIndex = eventTypes.indexOf('TEXT_MESSAGE_START')
+    const textContentIndex = eventTypes.indexOf('TEXT_MESSAGE_CONTENT')
+    expect(textStartIndex).toBeGreaterThan(-1)
+    expect(textContentIndex).toBeGreaterThan(textStartIndex)
+
+    // Should have TEXT_MESSAGE_END before RUN_FINISHED
+    const textEndIndex = eventTypes.indexOf('TEXT_MESSAGE_END')
+    const runFinishedIndex = eventTypes.indexOf('RUN_FINISHED')
+    expect(textEndIndex).toBeGreaterThan(-1)
+    expect(runFinishedIndex).toBeGreaterThan(textEndIndex)
+
+    // Verify RUN_FINISHED has proper data
+    const runFinishedChunk = chunks.find((c) => c.type === 'RUN_FINISHED')
+    if (runFinishedChunk?.type === 'RUN_FINISHED') {
+      expect(runFinishedChunk.finishReason).toBe('stop')
+      expect(runFinishedChunk.usage).toBeDefined()
+    }
+  })
+
+  it('streams content with correct accumulated values', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-stream',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: { content: 'Hello ' },
+            finish_reason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-stream',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: { content: 'world' },
+            finish_reason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-stream',
+        model: 'grok-3',
+        choices: [
+          {
+            delta: {},
+            finish_reason: 'stop',
+          },
+        ],
+        usage: {
+          prompt_tokens: 5,
+          completion_tokens: 2,
+          total_tokens: 7,
+        },
+      },
+    ]
+
+    setupMockSdkClient(streamChunks)
+    const adapter = createGrokText('grok-3', 'test-api-key')
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'grok-3',
+      messages: [{ role: 'user', content: 'Say hello' }],
+    })) {
+      chunks.push(chunk)
+    }
+
+    // Check TEXT_MESSAGE_CONTENT events have correct accumulated content
+    const contentChunks = chunks.filter(
+      (c) => c.type === 'TEXT_MESSAGE_CONTENT',
+    )
+    expect(contentChunks.length).toBe(2)
+
+    const firstContent = contentChunks[0]
+    if (firstContent?.type === 'TEXT_MESSAGE_CONTENT') {
+      expect(firstContent.delta).toBe('Hello ')
+      expect(firstContent.content).toBe('Hello ')
+    }
+
+    const secondContent = contentChunks[1]
+    if (secondContent?.type === 'TEXT_MESSAGE_CONTENT') {
+      expect(secondContent.delta).toBe('world')
+      expect(secondContent.content).toBe('Hello world')
+    }
+  })
+})
diff --git a/packages/typescript/ai-ollama/src/adapters/summarize.ts b/packages/typescript/ai-ollama/src/adapters/summarize.ts
index cf17d681..d4af2055 100644
--- a/packages/typescript/ai-ollama/src/adapters/summarize.ts
+++ b/packages/typescript/ai-ollama/src/adapters/summarize.ts
@@ -126,13 +126,12 @@ export class OllamaSummarizeAdapter<
       if (chunk.response) {
         accumulatedContent += chunk.response
         yield {
-          type: 'content',
-          id,
+          type: 'TEXT_MESSAGE_CONTENT',
+          messageId: id,
           model: chunk.model,
           timestamp: Date.now(),
           delta: chunk.response,
           content: accumulatedContent,
-          role: 'assistant',
         }
       }
 
@@ -140,8 +139,8 @@ export class OllamaSummarizeAdapter<
         const promptTokens = estimateTokens(prompt)
         const completionTokens = estimateTokens(accumulatedContent)
         yield {
-          type: 'done',
-          id,
+          type: 'RUN_FINISHED',
+          runId: id,
           model: chunk.model,
           timestamp: Date.now(),
           finishReason: 'stop',
diff --git a/packages/typescript/ai-ollama/src/adapters/text.ts b/packages/typescript/ai-ollama/src/adapters/text.ts
index 6fecd965..e96bd52e 100644
--- a/packages/typescript/ai-ollama/src/adapters/text.ts
+++ b/packages/typescript/ai-ollama/src/adapters/text.ts
@@ -186,90 +186,161 @@ export class OllamaTextAdapter<TModel extends string> extends BaseTextAdapter<
   ): AsyncIterable<StreamChunk> {
     let accumulatedContent = ''
     const timestamp = Date.now()
-    const responseId = generateId('msg')
     let accumulatedReasoning = ''
-    let hasEmittedToolCalls = false
+    const toolCallsEmitted = new Set<string>()
+
+    // AG-UI lifecycle tracking
+    const runId = generateId('run')
+    const messageId = generateId('msg')
+    let stepId: string | null = null
+    let hasEmittedRunStarted = false
+    let hasEmittedTextMessageStart = false
+    let hasEmittedStepStarted = false
 
     for await (const chunk of stream) {
-      const handleToolCall = (toolCall: ToolCall): StreamChunk => {
+      // Emit RUN_STARTED on first chunk
+      if (!hasEmittedRunStarted) {
+        hasEmittedRunStarted = true
+        yield {
+          type: 'RUN_STARTED',
+          runId,
+          model: chunk.model,
+          timestamp,
+        }
+      }
+
+      const handleToolCall = (toolCall: ToolCall): Array<StreamChunk> => {
         const actualToolCall = toolCall as ToolCall & {
           id: string
           function: { index: number }
         }
-        return {
-          type: 'tool_call',
-          id: responseId,
+        const toolCallId =
+          actualToolCall.id || `${actualToolCall.function.name}_${Date.now()}`
+        const events: Array<StreamChunk> = []
+
+        // Emit TOOL_CALL_START if not already emitted for this tool call
+        if (!toolCallsEmitted.has(toolCallId)) {
+          toolCallsEmitted.add(toolCallId)
+          events.push({
+            type: 'TOOL_CALL_START',
+            toolCallId,
+            toolName: actualToolCall.function.name || '',
+            model: chunk.model,
+            timestamp,
+            index: actualToolCall.function.index,
+          })
+        }
+
+        // Parse input
+        let parsedInput: unknown = {}
+        const argsStr =
+          typeof actualToolCall.function.arguments === 'string'
+            ? actualToolCall.function.arguments
+            : JSON.stringify(actualToolCall.function.arguments)
+        try {
+          parsedInput = JSON.parse(argsStr)
+        } catch {
+          parsedInput = actualToolCall.function.arguments
+        }
+
+        // Emit TOOL_CALL_END
+        events.push({
+          type: 'TOOL_CALL_END',
+          toolCallId,
+          toolName: actualToolCall.function.name || '',
           model: chunk.model,
           timestamp,
-          toolCall: {
-            type: 'function',
-            id: actualToolCall.id,
-            function: {
-              name: actualToolCall.function.name || '',
-              arguments:
-                typeof actualToolCall.function.arguments === 'string'
-                  ? actualToolCall.function.arguments
-                  : JSON.stringify(actualToolCall.function.arguments),
-            },
-          },
-          index: actualToolCall.function.index,
-        }
+          input: parsedInput,
+        })
+
+        return events
       }
 
       if (chunk.done) {
         if (chunk.message.tool_calls && chunk.message.tool_calls.length > 0) {
           for (const toolCall of chunk.message.tool_calls) {
-            yield handleToolCall(toolCall)
-            hasEmittedToolCalls = true
+            const events = handleToolCall(toolCall)
+            for (const event of events) {
+              yield event
+            }
           }
+        }
+
+        // Emit TEXT_MESSAGE_END if we had text content
+        if (hasEmittedTextMessageStart) {
           yield {
-            type: 'done',
-            id: responseId,
+            type: 'TEXT_MESSAGE_END',
+            messageId,
             model: chunk.model,
             timestamp,
-            finishReason: 'tool_calls',
           }
-          continue
         }
+
         yield {
-          type: 'done',
-          id: responseId,
+          type: 'RUN_FINISHED',
+          runId,
           model: chunk.model,
           timestamp,
-          finishReason: hasEmittedToolCalls ? 'tool_calls' : 'stop',
+          finishReason: toolCallsEmitted.size > 0 ? 'tool_calls' : 'stop',
         }
         continue
       }
 
       if (chunk.message.content) {
+        // Emit TEXT_MESSAGE_START on first text content
+        if (!hasEmittedTextMessageStart) {
+          hasEmittedTextMessageStart = true
+          yield {
+            type: 'TEXT_MESSAGE_START',
+            messageId,
+            model: chunk.model,
+            timestamp,
+            role: 'assistant',
+          }
+        }
+
         accumulatedContent += chunk.message.content
         yield {
-          type: 'content',
-          id: responseId,
+          type: 'TEXT_MESSAGE_CONTENT',
+          messageId,
           model: chunk.model,
           timestamp,
           delta: chunk.message.content,
           content: accumulatedContent,
-          role: 'assistant',
         }
       }
 
       if (chunk.message.tool_calls && chunk.message.tool_calls.length > 0) {
         for (const toolCall of chunk.message.tool_calls) {
-          yield handleToolCall(toolCall)
-          hasEmittedToolCalls = true
+          const events = handleToolCall(toolCall)
+          for (const event of events) {
+            yield event
+          }
         }
       }
 
       if (chunk.message.thinking) {
+        // Emit STEP_STARTED on first thinking content
+        if (!hasEmittedStepStarted) {
+          hasEmittedStepStarted = true
+          stepId = generateId('step')
+          yield {
+            type: 'STEP_STARTED',
+            stepId,
+            model: chunk.model,
+            timestamp,
+            stepType: 'thinking',
+          }
+        }
+
         accumulatedReasoning += chunk.message.thinking
         yield {
-          type: 'thinking',
-          id: responseId,
+          type: 'STEP_FINISHED',
+          stepId: stepId || generateId('step'),
           model: chunk.model,
           timestamp,
-          content: accumulatedReasoning,
           delta: chunk.message.thinking,
+          content: accumulatedReasoning,
         }
       }
     }
diff --git a/packages/typescript/ai-openai/src/adapters/summarize.ts b/packages/typescript/ai-openai/src/adapters/summarize.ts
index 944e8dea..6db5d874 100644
--- a/packages/typescript/ai-openai/src/adapters/summarize.ts
+++ b/packages/typescript/ai-openai/src/adapters/summarize.ts
@@ -48,7 +48,7 @@ export class OpenAISummarizeAdapter<
 
     // Use the text adapter's streaming and collect the result
     let summary = ''
-    let id = ''
+    const id = ''
     let model = options.model
     let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
 
@@ -59,13 +59,20 @@ export class OpenAISummarizeAdapter<
       maxTokens: options.maxLength,
       temperature: 0.3,
     })) {
-      if (chunk.type === 'content') {
-        summary = chunk.content
-        id = chunk.id
-        model = chunk.model
+      // AG-UI TEXT_MESSAGE_CONTENT event
+      if (chunk.type === 'TEXT_MESSAGE_CONTENT') {
+        if (chunk.content) {
+          summary = chunk.content
+        } else {
+          summary += chunk.delta
+        }
+        model = chunk.model || model
       }
-      if (chunk.type === 'done' && chunk.usage) {
-        usage = chunk.usage
+      // AG-UI RUN_FINISHED event
+      if (chunk.type === 'RUN_FINISHED') {
+        if (chunk.usage) {
+          usage = chunk.usage
+        }
       }
     }
 
diff --git a/packages/typescript/ai-openai/src/adapters/text.ts b/packages/typescript/ai-openai/src/adapters/text.ts
index e48fc2cd..b367afcc 100644
--- a/packages/typescript/ai-openai/src/adapters/text.ts
+++ b/packages/typescript/ai-openai/src/adapters/text.ts
@@ -105,7 +105,10 @@ export class OpenAITextAdapter<
     // Track tool call metadata by unique ID
     // OpenAI streams tool calls with deltas - first chunk has ID/name, subsequent chunks only have args
     // We assign our own indices as we encounter unique tool call IDs
-    const toolCallMetadata = new Map<string, { index: number; name: string }>()
+    const toolCallMetadata = new Map<
+      string,
+      { index: number; name: string; started: boolean }
+    >()
     const requestArguments = this.mapTextOptionsToOpenAI(options)
 
     try {
@@ -234,7 +237,10 @@ export class OpenAITextAdapter<
 
   private async *processOpenAIStreamChunks(
     stream: AsyncIterable<OpenAI_SDK.Responses.ResponseStreamEvent>,
-    toolCallMetadata: Map<string, { index: number; name: string }>,
+    toolCallMetadata: Map<
+      string,
+      { index: number; name: string; started: boolean }
+    >,
     options: TextOptions,
     genId: () => string,
   ): AsyncIterable<StreamChunk> {
@@ -248,12 +254,31 @@ export class OpenAITextAdapter<
     let hasStreamedReasoningDeltas = false
 
     // Preserve response metadata across events
-    let responseId: string | null = null
     let model: string = options.model
 
+    // AG-UI lifecycle tracking
+    const runId = genId()
+    const messageId = genId()
+    let stepId: string | null = null
+    let hasEmittedRunStarted = false
+    let hasEmittedTextMessageStart = false
+    let hasEmittedStepStarted = false
+
     try {
       for await (const chunk of stream) {
         chunkCount++
+
+        // Emit RUN_STARTED on first chunk
+        if (!hasEmittedRunStarted) {
+          hasEmittedRunStarted = true
+          yield {
+            type: 'RUN_STARTED',
+            runId,
+            model: model || options.model,
+            timestamp,
+          }
+        }
+
         const handleContentPart = (
           contentPart:
             | OpenAI_SDK.Responses.ResponseOutputText
@@ -263,21 +288,20 @@ export class OpenAITextAdapter<
           if (contentPart.type === 'output_text') {
             accumulatedContent += contentPart.text
             return {
-              type: 'content',
-              id: responseId || genId(),
+              type: 'TEXT_MESSAGE_CONTENT',
+              messageId,
               model: model || options.model,
               timestamp,
               delta: contentPart.text,
               content: accumulatedContent,
-              role: 'assistant',
             }
           }
 
           if (contentPart.type === 'reasoning_text') {
             accumulatedReasoning += contentPart.text
             return {
-              type: 'thinking',
-              id: responseId || genId(),
+              type: 'STEP_FINISHED',
+              stepId: stepId || genId(),
               model: model || options.model,
               timestamp,
               delta: contentPart.text,
@@ -285,8 +309,8 @@ export class OpenAITextAdapter<
             }
           }
           return {
-            type: 'error',
-            id: responseId || genId(),
+            type: 'RUN_ERROR',
+            runId,
             model: model || options.model,
             timestamp,
             error: {
@@ -300,17 +324,18 @@ export class OpenAITextAdapter<
           chunk.type === 'response.incomplete' ||
           chunk.type === 'response.failed'
         ) {
-          responseId = chunk.response.id
           model = chunk.response.model
           // Reset streaming flags for new response
           hasStreamedContentDeltas = false
           hasStreamedReasoningDeltas = false
+          hasEmittedTextMessageStart = false
+          hasEmittedStepStarted = false
           accumulatedContent = ''
           accumulatedReasoning = ''
           if (chunk.response.error) {
             yield {
-              type: 'error',
-              id: chunk.response.id,
+              type: 'RUN_ERROR',
+              runId,
               model: chunk.response.model,
               timestamp,
               error: chunk.response.error,
@@ -318,8 +343,8 @@ export class OpenAITextAdapter<
           }
           if (chunk.response.incomplete_details) {
             yield {
-              type: 'error',
-              id: chunk.response.id,
+              type: 'RUN_ERROR',
+              runId,
               model: chunk.response.model,
               timestamp,
               error: {
@@ -339,16 +364,27 @@ export class OpenAITextAdapter<
               : ''
 
           if (textDelta) {
+            // Emit TEXT_MESSAGE_START on first text content
+            if (!hasEmittedTextMessageStart) {
+              hasEmittedTextMessageStart = true
+              yield {
+                type: 'TEXT_MESSAGE_START',
+                messageId,
+                model: model || options.model,
+                timestamp,
+                role: 'assistant',
+              }
+            }
+
             accumulatedContent += textDelta
             hasStreamedContentDeltas = true
             yield {
-              type: 'content',
-              id: responseId || genId(),
+              type: 'TEXT_MESSAGE_CONTENT',
+              messageId,
               model: model || options.model,
               timestamp,
               delta: textDelta,
               content: accumulatedContent,
-              role: 'assistant',
             }
           }
         }
@@ -364,11 +400,24 @@ export class OpenAITextAdapter<
               : ''
 
           if (reasoningDelta) {
+            // Emit STEP_STARTED on first reasoning content
+            if (!hasEmittedStepStarted) {
+              hasEmittedStepStarted = true
+              stepId = genId()
+              yield {
+                type: 'STEP_STARTED',
+                stepId,
+                model: model || options.model,
+                timestamp,
+                stepType: 'thinking',
+              }
+            }
+
             accumulatedReasoning += reasoningDelta
             hasStreamedReasoningDeltas = true
             yield {
-              type: 'thinking',
-              id: responseId || genId(),
+              type: 'STEP_FINISHED',
+              stepId: stepId || genId(),
               model: model || options.model,
               timestamp,
               delta: reasoningDelta,
@@ -387,11 +436,24 @@ export class OpenAITextAdapter<
             typeof chunk.delta === 'string' ? chunk.delta : ''
 
           if (summaryDelta) {
+            // Emit STEP_STARTED on first reasoning content
+            if (!hasEmittedStepStarted) {
+              hasEmittedStepStarted = true
+              stepId = genId()
+              yield {
+                type: 'STEP_STARTED',
+                stepId,
+                model: model || options.model,
+                timestamp,
+                stepType: 'thinking',
+              }
+            }
+
             accumulatedReasoning += summaryDelta
             hasStreamedReasoningDeltas = true
             yield {
-              type: 'thinking',
-              id: responseId || genId(),
+              type: 'STEP_FINISHED',
+              stepId: stepId || genId(),
               model: model || options.model,
               timestamp,
               delta: summaryDelta,
@@ -403,6 +465,32 @@ export class OpenAITextAdapter<
         // handle content_part added events for text, reasoning and refusals
         if (chunk.type === 'response.content_part.added') {
           const contentPart = chunk.part
+          // Emit TEXT_MESSAGE_START if this is text content
+          if (
+            contentPart.type === 'output_text' &&
+            !hasEmittedTextMessageStart
+          ) {
+            hasEmittedTextMessageStart = true
+            yield {
+              type: 'TEXT_MESSAGE_START',
+              messageId,
+              model: model || options.model,
+              timestamp,
+              role: 'assistant',
+            }
+          }
+          // Emit STEP_STARTED if this is reasoning content
+          if (contentPart.type === 'reasoning_text' && !hasEmittedStepStarted) {
+            hasEmittedStepStarted = true
+            stepId = genId()
+            yield {
+              type: 'STEP_STARTED',
+              stepId,
+              model: model || options.model,
+              timestamp,
+              stepType: 'thinking',
+            }
+          }
           yield handleContentPart(contentPart)
         }
 
@@ -436,36 +524,74 @@ export class OpenAITextAdapter<
               toolCallMetadata.set(item.id, {
                 index: chunk.output_index,
                 name: item.name || '',
+                started: false,
               })
             }
+            // Emit TOOL_CALL_START
+            yield {
+              type: 'TOOL_CALL_START',
+              toolCallId: item.id,
+              toolName: item.name || '',
+              model: model || options.model,
+              timestamp,
+              index: chunk.output_index,
+            }
+            toolCallMetadata.get(item.id)!.started = true
+          }
+        }
+
+        // Handle function call arguments delta (streaming)
+        if (
+          chunk.type === 'response.function_call_arguments.delta' &&
+          chunk.delta
+        ) {
+          const metadata = toolCallMetadata.get(chunk.item_id)
+          yield {
+            type: 'TOOL_CALL_ARGS',
+            toolCallId: chunk.item_id,
+            model: model || options.model,
+            timestamp,
+            delta: chunk.delta,
+            args: metadata ? undefined : chunk.delta, // We don't accumulate here, let caller handle it
           }
         }
 
         if (chunk.type === 'response.function_call_arguments.done') {
-          const { item_id, output_index } = chunk
+          const { item_id } = chunk
 
           // Get the function name from metadata (captured in output_item.added)
           const metadata = toolCallMetadata.get(item_id)
           const name = metadata?.name || ''
 
+          // Parse arguments
+          let parsedInput: unknown = {}
+          try {
+            parsedInput = chunk.arguments ? JSON.parse(chunk.arguments) : {}
+          } catch {
+            parsedInput = {}
+          }
+
           yield {
-            type: 'tool_call',
-            id: responseId || genId(),
+            type: 'TOOL_CALL_END',
+            toolCallId: item_id,
+            toolName: name,
             model: model || options.model,
             timestamp,
-            index: output_index,
-            toolCall: {
-              id: item_id,
-              type: 'function',
-              function: {
-                name,
-                arguments: chunk.arguments,
-              },
-            },
+            input: parsedInput,
           }
         }
 
         if (chunk.type === 'response.completed') {
+          // Emit TEXT_MESSAGE_END if we had text content
+          if (hasEmittedTextMessageStart) {
+            yield {
+              type: 'TEXT_MESSAGE_END',
+              messageId,
+              model: model || options.model,
+              timestamp,
+            }
+          }
+
           // Determine finish reason based on output
           // If there are function_call items in the output, it's a tool_calls finish
           const hasFunctionCalls = chunk.response.output.some(
@@ -474,8 +600,8 @@ export class OpenAITextAdapter<
           )
 
           yield {
-            type: 'done',
-            id: responseId || genId(),
+            type: 'RUN_FINISHED',
+            runId,
             model: model || options.model,
             timestamp,
             usage: {
@@ -489,8 +615,8 @@ export class OpenAITextAdapter<
 
         if (chunk.type === 'error') {
           yield {
-            type: 'error',
-            id: responseId || genId(),
+            type: 'RUN_ERROR',
+            runId,
             model: model || options.model,
             timestamp,
             error: {
@@ -510,8 +636,8 @@ export class OpenAITextAdapter<
         },
       )
       yield {
-        type: 'error',
-        id: genId(),
+        type: 'RUN_ERROR',
+        runId,
         model: options.model,
         timestamp,
         error: {
diff --git a/packages/typescript/ai-openrouter/src/adapters/summarize.ts b/packages/typescript/ai-openrouter/src/adapters/summarize.ts
index a046d8a2..faa4d2e2 100644
--- a/packages/typescript/ai-openrouter/src/adapters/summarize.ts
+++ b/packages/typescript/ai-openrouter/src/adapters/summarize.ts
@@ -59,7 +59,7 @@ export class OpenRouterSummarizeAdapter<
     const systemPrompt = this.buildSummarizationPrompt(options)
 
     let summary = ''
-    let id = ''
+    const id = ''
     let model = options.model
     let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
 
@@ -70,15 +70,23 @@ export class OpenRouterSummarizeAdapter<
       maxTokens: this.maxTokens ?? options.maxLength,
       temperature: this.temperature,
     })) {
-      if (chunk.type === 'content') {
-        summary = chunk.content
-        id = chunk.id
-        model = chunk.model
+      // AG-UI TEXT_MESSAGE_CONTENT event
+      if (chunk.type === 'TEXT_MESSAGE_CONTENT') {
+        if (chunk.content) {
+          summary = chunk.content
+        } else {
+          summary += chunk.delta
+        }
+        model = chunk.model || model
       }
-      if (chunk.type === 'done' && chunk.usage) {
-        usage = chunk.usage
+      // AG-UI RUN_FINISHED event
+      if (chunk.type === 'RUN_FINISHED') {
+        if (chunk.usage) {
+          usage = chunk.usage
+        }
       }
-      if (chunk.type === 'error') {
+      // AG-UI RUN_ERROR event
+      if (chunk.type === 'RUN_ERROR') {
         throw new Error(`Error during summarization: ${chunk.error.message}`)
       }
     }
diff --git a/packages/typescript/ai-openrouter/src/adapters/text.ts b/packages/typescript/ai-openrouter/src/adapters/text.ts
index b0a8147f..d3a7e6a5 100644
--- a/packages/typescript/ai-openrouter/src/adapters/text.ts
+++ b/packages/typescript/ai-openrouter/src/adapters/text.ts
@@ -59,6 +59,17 @@ interface ToolCallBuffer {
   id: string
   name: string
   arguments: string
+  started: boolean // Track if TOOL_CALL_START has been emitted
+}
+
+// AG-UI lifecycle state tracking
+interface AGUIState {
+  runId: string
+  messageId: string
+  stepId: string | null
+  hasEmittedRunStarted: boolean
+  hasEmittedTextMessageStart: boolean
+  hasEmittedStepStarted: boolean
 }
 
 export class OpenRouterTextAdapter<
@@ -89,6 +100,17 @@ export class OpenRouterTextAdapter<
     let responseId: string | null = null
     let currentModel = options.model
     let lastFinishReason: ChatCompletionFinishReason | undefined
+
+    // AG-UI lifecycle tracking
+    const aguiState: AGUIState = {
+      runId: this.generateId(),
+      messageId: this.generateId(),
+      stepId: null,
+      hasEmittedRunStarted: false,
+      hasEmittedTextMessageStart: false,
+      hasEmittedStepStarted: false,
+    }
+
     try {
       const requestParams = this.mapTextOptionsToSDK(options)
       const stream = await this.client.chat.send(
@@ -100,13 +122,29 @@ export class OpenRouterTextAdapter<
         if (chunk.id) responseId = chunk.id
         if (chunk.model) currentModel = chunk.model
 
+        // Emit RUN_STARTED on first chunk
+        if (!aguiState.hasEmittedRunStarted) {
+          aguiState.hasEmittedRunStarted = true
+          yield {
+            type: 'RUN_STARTED',
+            runId: aguiState.runId,
+            model: currentModel || options.model,
+            timestamp,
+          }
+        }
+
         if (chunk.error) {
-          yield this.createErrorChunk(
-            chunk.error.message || 'Unknown error',
-            currentModel || options.model,
+          // Emit AG-UI RUN_ERROR
+          yield {
+            type: 'RUN_ERROR',
+            runId: aguiState.runId,
+            model: currentModel || options.model,
             timestamp,
-            String(chunk.error.code),
-          )
+            error: {
+              message: chunk.error.message || 'Unknown error',
+              code: String(chunk.error.code),
+            },
+          }
           continue
         }
 
@@ -129,24 +167,47 @@ export class OpenRouterTextAdapter<
             },
             lastFinishReason,
             chunk.usage,
+            aguiState,
           )
         }
       }
     } catch (error) {
+      // Emit RUN_STARTED if not yet emitted (error on first call)
+      if (!aguiState.hasEmittedRunStarted) {
+        aguiState.hasEmittedRunStarted = true
+        yield {
+          type: 'RUN_STARTED',
+          runId: aguiState.runId,
+          model: options.model,
+          timestamp,
+        }
+      }
+
       if (error instanceof RequestAbortedError) {
-        yield this.createErrorChunk(
-          'Request aborted',
-          options.model,
+        // Emit AG-UI RUN_ERROR
+        yield {
+          type: 'RUN_ERROR',
+          runId: aguiState.runId,
+          model: options.model,
           timestamp,
-          'aborted',
-        )
+          error: {
+            message: 'Request aborted',
+            code: 'aborted',
+          },
+        }
         return
       }
-      yield this.createErrorChunk(
-        (error as Error).message || 'Unknown error',
-        options.model,
+
+      // Emit AG-UI RUN_ERROR
+      yield {
+        type: 'RUN_ERROR',
+        runId: aguiState.runId,
+        model: options.model,
         timestamp,
-      )
+        error: {
+          message: (error as Error).message || 'Unknown error',
+        },
+      }
     }
   }
 
@@ -221,21 +282,6 @@ export class OpenRouterTextAdapter<
     return utilGenerateId(this.name)
   }
 
-  private createErrorChunk(
-    message: string,
-    model: string,
-    timestamp: number,
-    code?: string,
-  ): StreamChunk {
-    return {
-      type: 'error',
-      id: this.generateId(),
-      model,
-      timestamp,
-      error: { message, code },
-    }
-  }
-
   private *processChoice(
     choice: ChatStreamingChoice,
     toolCallBuffers: Map<number, ToolCallBuffer>,
@@ -243,20 +289,36 @@ export class OpenRouterTextAdapter<
     accumulated: { reasoning: string; content: string },
     updateAccumulated: (reasoning: string, content: string) => void,
     lastFinishReason: ChatCompletionFinishReason | undefined,
-    usage?: ChatGenerationTokenUsage,
+    usage: ChatGenerationTokenUsage | undefined,
+    aguiState: AGUIState,
   ): Iterable<StreamChunk> {
     const delta = choice.delta
     const finishReason = choice.finishReason
 
     if (delta.content) {
+      // Emit TEXT_MESSAGE_START on first text content
+      if (!aguiState.hasEmittedTextMessageStart) {
+        aguiState.hasEmittedTextMessageStart = true
+        yield {
+          type: 'TEXT_MESSAGE_START',
+          messageId: aguiState.messageId,
+          model: meta.model,
+          timestamp: meta.timestamp,
+          role: 'assistant',
+        }
+      }
+
       accumulated.content += delta.content
       updateAccumulated(accumulated.reasoning, accumulated.content)
+
+      // Emit AG-UI TEXT_MESSAGE_CONTENT
       yield {
-        type: 'content',
-        ...meta,
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: aguiState.messageId,
+        model: meta.model,
+        timestamp: meta.timestamp,
         delta: delta.content,
         content: accumulated.content,
-        role: 'assistant',
       }
     }
 
@@ -264,11 +326,29 @@ export class OpenRouterTextAdapter<
       for (const detail of delta.reasoningDetails) {
         if (detail.type === 'reasoning.text') {
           const text = detail.text || ''
+
+          // Emit STEP_STARTED on first reasoning content
+          if (!aguiState.hasEmittedStepStarted) {
+            aguiState.hasEmittedStepStarted = true
+            aguiState.stepId = this.generateId()
+            yield {
+              type: 'STEP_STARTED',
+              stepId: aguiState.stepId,
+              model: meta.model,
+              timestamp: meta.timestamp,
+              stepType: 'thinking',
+            }
+          }
+
           accumulated.reasoning += text
           updateAccumulated(accumulated.reasoning, accumulated.content)
+
+          // Emit AG-UI STEP_FINISHED for reasoning delta
           yield {
-            type: 'thinking',
-            ...meta,
+            type: 'STEP_FINISHED',
+            stepId: aguiState.stepId!,
+            model: meta.model,
+            timestamp: meta.timestamp,
             delta: text,
             content: accumulated.reasoning,
           }
@@ -276,11 +356,29 @@ export class OpenRouterTextAdapter<
         }
         if (detail.type === 'reasoning.summary') {
           const text = detail.summary || ''
+
+          // Emit STEP_STARTED on first reasoning content
+          if (!aguiState.hasEmittedStepStarted) {
+            aguiState.hasEmittedStepStarted = true
+            aguiState.stepId = this.generateId()
+            yield {
+              type: 'STEP_STARTED',
+              stepId: aguiState.stepId,
+              model: meta.model,
+              timestamp: meta.timestamp,
+              stepType: 'thinking',
+            }
+          }
+
           accumulated.reasoning += text
           updateAccumulated(accumulated.reasoning, accumulated.content)
+
+          // Emit AG-UI STEP_FINISHED for reasoning delta
           yield {
-            type: 'thinking',
-            ...meta,
+            type: 'STEP_FINISHED',
+            stepId: aguiState.stepId!,
+            model: meta.model,
+            timestamp: meta.timestamp,
             delta: text,
             content: accumulated.reasoning,
           }
@@ -300,35 +398,73 @@ export class OpenRouterTextAdapter<
             id: tc.id,
             name: tc.function?.name ?? '',
             arguments: tc.function?.arguments ?? '',
+            started: false,
           })
         } else {
           if (tc.function?.name) existing.name = tc.function.name
           if (tc.function?.arguments)
             existing.arguments += tc.function.arguments
         }
+
+        // Get the current buffer (existing or newly created)
+        const buffer = toolCallBuffers.get(tc.index)!
+
+        // Emit TOOL_CALL_START when we have id and name
+        if (buffer.id && buffer.name && !buffer.started) {
+          buffer.started = true
+          yield {
+            type: 'TOOL_CALL_START',
+            toolCallId: buffer.id,
+            toolName: buffer.name,
+            model: meta.model,
+            timestamp: meta.timestamp,
+            index: tc.index,
+          }
+        }
+
+        // Emit TOOL_CALL_ARGS for argument deltas
+        if (tc.function?.arguments && buffer.started) {
+          yield {
+            type: 'TOOL_CALL_ARGS',
+            toolCallId: buffer.id,
+            model: meta.model,
+            timestamp: meta.timestamp,
+            delta: tc.function.arguments,
+          }
+        }
       }
     }
 
     if (delta.refusal) {
+      // Emit AG-UI RUN_ERROR for refusal
       yield {
-        type: 'error',
-        ...meta,
+        type: 'RUN_ERROR',
+        runId: aguiState.runId,
+        model: meta.model,
+        timestamp: meta.timestamp,
         error: { message: delta.refusal, code: 'refusal' },
       }
     }
 
     if (finishReason) {
       if (finishReason === 'tool_calls') {
-        for (const [index, tc] of toolCallBuffers.entries()) {
+        for (const [, tc] of toolCallBuffers.entries()) {
+          // Parse arguments for TOOL_CALL_END
+          let parsedInput: unknown = {}
+          try {
+            parsedInput = tc.arguments ? JSON.parse(tc.arguments) : {}
+          } catch {
+            parsedInput = {}
+          }
+
+          // Emit AG-UI TOOL_CALL_END
           yield {
-            type: 'tool_call',
-            ...meta,
-            index,
-            toolCall: {
-              id: tc.id,
-              type: 'function',
-              function: { name: tc.name, arguments: tc.arguments },
-            },
+            type: 'TOOL_CALL_END',
+            toolCallId: tc.id,
+            toolName: tc.name,
+            model: meta.model,
+            timestamp: meta.timestamp,
+            input: parsedInput,
           }
         }
 
@@ -336,20 +472,35 @@ export class OpenRouterTextAdapter<
       }
     }
     if (usage) {
+      const computedFinishReason =
+        lastFinishReason === 'tool_calls'
+          ? 'tool_calls'
+          : lastFinishReason === 'length'
+            ? 'length'
+            : 'stop'
+
+      // Emit TEXT_MESSAGE_END if we had text content
+      if (aguiState.hasEmittedTextMessageStart) {
+        yield {
+          type: 'TEXT_MESSAGE_END',
+          messageId: aguiState.messageId,
+          model: meta.model,
+          timestamp: meta.timestamp,
+        }
+      }
+
+      // Emit AG-UI RUN_FINISHED
       yield {
-        type: 'done',
-        ...meta,
-        finishReason:
-          lastFinishReason === 'tool_calls'
-            ? 'tool_calls'
-            : lastFinishReason === 'length'
-              ? 'length'
-              : 'stop',
+        type: 'RUN_FINISHED',
+        runId: aguiState.runId,
+        model: meta.model,
+        timestamp: meta.timestamp,
         usage: {
           promptTokens: usage.promptTokens || 0,
           completionTokens: usage.completionTokens || 0,
           totalTokens: usage.totalTokens || 0,
         },
+        finishReason: computedFinishReason,
       }
     }
   }
diff --git a/packages/typescript/ai-openrouter/tests/openrouter-adapter.test.ts b/packages/typescript/ai-openrouter/tests/openrouter-adapter.test.ts
index fbe47f8f..2ba49c6b 100644
--- a/packages/typescript/ai-openrouter/tests/openrouter-adapter.test.ts
+++ b/packages/typescript/ai-openrouter/tests/openrouter-adapter.test.ts
@@ -199,23 +199,27 @@ describe('OpenRouter adapter option mapping', () => {
       chunks.push(chunk)
     }
 
-    expect(chunks[0]).toMatchObject({
-      type: 'content',
+    // AG-UI events: RUN_STARTED, TEXT_MESSAGE_START, TEXT_MESSAGE_CONTENT, ...
+    const contentChunks = chunks.filter(
+      (c) => c.type === 'TEXT_MESSAGE_CONTENT',
+    )
+    expect(contentChunks.length).toBe(2)
+
+    expect(contentChunks[0]).toMatchObject({
+      type: 'TEXT_MESSAGE_CONTENT',
       delta: 'Hello ',
       content: 'Hello ',
     })
 
-    expect(chunks[1]).toMatchObject({
-      type: 'content',
+    expect(contentChunks[1]).toMatchObject({
+      type: 'TEXT_MESSAGE_CONTENT',
       delta: 'world',
       content: 'Hello world',
     })
 
-    const doneChunk = chunks.find(
-      (c) => c.type === 'done' && 'usage' in c && c.usage,
-    )
-    expect(doneChunk).toMatchObject({
-      type: 'done',
+    const runFinishedChunk = chunks.find((c) => c.type === 'RUN_FINISHED')
+    expect(runFinishedChunk).toMatchObject({
+      type: 'RUN_FINISHED',
       finishReason: 'stop',
       usage: {
         promptTokens: 5,
@@ -290,22 +294,23 @@ describe('OpenRouter adapter option mapping', () => {
     const adapter = createAdapter()
 
     const chunks: Array<StreamChunk> = []
-    for await (const chunk of chat({
-      adapter,
+    for await (const chunk of adapter.chatStream({
+      model: 'openai/gpt-4o-mini',
       messages: [{ role: 'user', content: 'What is the weather in Berlin?' }],
       tools: [weatherTool],
     })) {
       chunks.push(chunk)
     }
 
-    const toolCallChunks = chunks.filter((c) => c.type === 'tool_call')
-    expect(toolCallChunks.length).toBe(1)
+    // Check for AG-UI TOOL_CALL_END event
+    const toolCallEndChunks = chunks.filter((c) => c.type === 'TOOL_CALL_END')
+    expect(toolCallEndChunks.length).toBe(1)
 
-    const toolCallChunk = toolCallChunks[0]
-    expect(toolCallChunk?.toolCall.function.name).toBe('lookup_weather')
-    expect(toolCallChunk?.toolCall.function.arguments).toBe(
-      '{"location":"Berlin"}',
-    )
+    const toolCallEndChunk = toolCallEndChunks[0]
+    if (toolCallEndChunk?.type === 'TOOL_CALL_END') {
+      expect(toolCallEndChunk.toolName).toBe('lookup_weather')
+      expect(toolCallEndChunk.input).toEqual({ location: 'Berlin' })
+    }
   })
 
   it('handles multimodal input with text and image', async () => {
@@ -370,11 +375,447 @@ describe('OpenRouter adapter option mapping', () => {
       chunks.push(chunk)
     }
 
-    expect(chunks.length).toBe(1)
-    expect(chunks[0]!.type).toBe('error')
+    expect(chunks.length).toBeGreaterThanOrEqual(1)
+    // Should emit AG-UI RUN_ERROR
+    const errorChunk = chunks.find((c) => c.type === 'RUN_ERROR')
+    expect(errorChunk).toBeDefined()
+
+    if (errorChunk && errorChunk.type === 'RUN_ERROR') {
+      expect(errorChunk.error.message).toBe('Invalid API key')
+    }
+  })
+})
+
+describe('OpenRouter AG-UI event emission', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('emits RUN_STARTED as the first event', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-123',
+        model: 'openai/gpt-4o-mini',
+        choices: [
+          {
+            delta: { content: 'Hello' },
+            finishReason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-123',
+        model: 'openai/gpt-4o-mini',
+        choices: [
+          {
+            delta: {},
+            finishReason: 'stop',
+          },
+        ],
+        usage: {
+          promptTokens: 5,
+          completionTokens: 1,
+          totalTokens: 6,
+        },
+      },
+    ]
+
+    setupMockSdkClient(streamChunks)
+    const adapter = createAdapter()
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'openai/gpt-4o-mini',
+      messages: [{ role: 'user', content: 'Hello' }],
+    })) {
+      chunks.push(chunk)
+    }
+
+    expect(chunks[0]?.type).toBe('RUN_STARTED')
+    if (chunks[0]?.type === 'RUN_STARTED') {
+      expect(chunks[0].runId).toBeDefined()
+      expect(chunks[0].model).toBe('openai/gpt-4o-mini')
+    }
+  })
+
+  it('emits TEXT_MESSAGE_START before TEXT_MESSAGE_CONTENT', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-123',
+        model: 'openai/gpt-4o-mini',
+        choices: [
+          {
+            delta: { content: 'Hello' },
+            finishReason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-123',
+        model: 'openai/gpt-4o-mini',
+        choices: [
+          {
+            delta: {},
+            finishReason: 'stop',
+          },
+        ],
+        usage: {
+          promptTokens: 5,
+          completionTokens: 1,
+          totalTokens: 6,
+        },
+      },
+    ]
+
+    setupMockSdkClient(streamChunks)
+    const adapter = createAdapter()
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'openai/gpt-4o-mini',
+      messages: [{ role: 'user', content: 'Hello' }],
+    })) {
+      chunks.push(chunk)
+    }
+
+    const textStartIndex = chunks.findIndex(
+      (c) => c.type === 'TEXT_MESSAGE_START',
+    )
+    const textContentIndex = chunks.findIndex(
+      (c) => c.type === 'TEXT_MESSAGE_CONTENT',
+    )
+
+    expect(textStartIndex).toBeGreaterThan(-1)
+    expect(textContentIndex).toBeGreaterThan(-1)
+    expect(textStartIndex).toBeLessThan(textContentIndex)
+
+    const textStart = chunks[textStartIndex]
+    if (textStart?.type === 'TEXT_MESSAGE_START') {
+      expect(textStart.messageId).toBeDefined()
+      expect(textStart.role).toBe('assistant')
+    }
+  })
+
+  it('emits TEXT_MESSAGE_END and RUN_FINISHED at the end', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-123',
+        model: 'openai/gpt-4o-mini',
+        choices: [
+          {
+            delta: { content: 'Hello' },
+            finishReason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-123',
+        model: 'openai/gpt-4o-mini',
+        choices: [
+          {
+            delta: {},
+            finishReason: 'stop',
+          },
+        ],
+        usage: {
+          promptTokens: 5,
+          completionTokens: 1,
+          totalTokens: 6,
+        },
+      },
+    ]
+
+    setupMockSdkClient(streamChunks)
+    const adapter = createAdapter()
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'openai/gpt-4o-mini',
+      messages: [{ role: 'user', content: 'Hello' }],
+    })) {
+      chunks.push(chunk)
+    }
+
+    const textEndChunk = chunks.find((c) => c.type === 'TEXT_MESSAGE_END')
+    expect(textEndChunk).toBeDefined()
+    if (textEndChunk?.type === 'TEXT_MESSAGE_END') {
+      expect(textEndChunk.messageId).toBeDefined()
+    }
+
+    const runFinishedChunk = chunks.find((c) => c.type === 'RUN_FINISHED')
+    expect(runFinishedChunk).toBeDefined()
+    if (runFinishedChunk?.type === 'RUN_FINISHED') {
+      expect(runFinishedChunk.runId).toBeDefined()
+      expect(runFinishedChunk.finishReason).toBe('stop')
+      expect(runFinishedChunk.usage).toMatchObject({
+        promptTokens: 5,
+        completionTokens: 1,
+        totalTokens: 6,
+      })
+    }
+  })
+
+  it('emits AG-UI tool call events', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-456',
+        model: 'openai/gpt-4o-mini',
+        choices: [
+          {
+            delta: {
+              toolCalls: [
+                {
+                  index: 0,
+                  id: 'call_abc123',
+                  type: 'function',
+                  function: {
+                    name: 'lookup_weather',
+                    arguments: '{"location":',
+                  },
+                },
+              ],
+            },
+            finishReason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-456',
+        model: 'openai/gpt-4o-mini',
+        choices: [
+          {
+            delta: {
+              toolCalls: [
+                {
+                  index: 0,
+                  function: {
+                    arguments: '"Berlin"}',
+                  },
+                },
+              ],
+            },
+            finishReason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-456',
+        model: 'openai/gpt-4o-mini',
+        choices: [
+          {
+            delta: {},
+            finishReason: 'tool_calls',
+          },
+        ],
+        usage: {
+          promptTokens: 10,
+          completionTokens: 5,
+          totalTokens: 15,
+        },
+      },
+    ]
+
+    setupMockSdkClient(streamChunks)
+    const adapter = createAdapter()
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'openai/gpt-4o-mini',
+      messages: [{ role: 'user', content: 'Weather in Berlin?' }],
+      tools: [weatherTool],
+    })) {
+      chunks.push(chunk)
+    }
+
+    // Check AG-UI tool events
+    const toolStartChunk = chunks.find((c) => c.type === 'TOOL_CALL_START')
+    expect(toolStartChunk).toBeDefined()
+    if (toolStartChunk?.type === 'TOOL_CALL_START') {
+      expect(toolStartChunk.toolCallId).toBe('call_abc123')
+      expect(toolStartChunk.toolName).toBe('lookup_weather')
+    }
+
+    const toolArgsChunks = chunks.filter((c) => c.type === 'TOOL_CALL_ARGS')
+    expect(toolArgsChunks.length).toBeGreaterThan(0)
+
+    const toolEndChunk = chunks.find((c) => c.type === 'TOOL_CALL_END')
+    expect(toolEndChunk).toBeDefined()
+    if (toolEndChunk?.type === 'TOOL_CALL_END') {
+      expect(toolEndChunk.toolCallId).toBe('call_abc123')
+      expect(toolEndChunk.toolName).toBe('lookup_weather')
+      expect(toolEndChunk.input).toEqual({ location: 'Berlin' })
+    }
+
+    // Check finish reason
+    const runFinishedChunk = chunks.find((c) => c.type === 'RUN_FINISHED')
+    if (runFinishedChunk?.type === 'RUN_FINISHED') {
+      expect(runFinishedChunk.finishReason).toBe('tool_calls')
+    }
+  })
+
+  it('emits RUN_ERROR on SDK error', async () => {
+    mockSend = vi.fn().mockRejectedValueOnce(new Error('API key invalid'))
+
+    const adapter = createAdapter()
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'openai/gpt-4o-mini',
+      messages: [{ role: 'user', content: 'Hello' }],
+    })) {
+      chunks.push(chunk)
+    }
+
+    // Should emit RUN_STARTED even on error
+    const runStartedChunk = chunks.find((c) => c.type === 'RUN_STARTED')
+    expect(runStartedChunk).toBeDefined()
+
+    // Should emit RUN_ERROR
+    const runErrorChunk = chunks.find((c) => c.type === 'RUN_ERROR')
+    expect(runErrorChunk).toBeDefined()
+    if (runErrorChunk?.type === 'RUN_ERROR') {
+      expect(runErrorChunk.error.message).toBe('API key invalid')
+    }
+  })
+
+  it('emits proper AG-UI event sequence', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-123',
+        model: 'openai/gpt-4o-mini',
+        choices: [
+          {
+            delta: { content: 'Hello world' },
+            finishReason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-123',
+        model: 'openai/gpt-4o-mini',
+        choices: [
+          {
+            delta: {},
+            finishReason: 'stop',
+          },
+        ],
+        usage: {
+          promptTokens: 5,
+          completionTokens: 2,
+          totalTokens: 7,
+        },
+      },
+    ]
+
+    setupMockSdkClient(streamChunks)
+    const adapter = createAdapter()
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'openai/gpt-4o-mini',
+      messages: [{ role: 'user', content: 'Hello' }],
+    })) {
+      chunks.push(chunk)
+    }
+
+    // Verify proper AG-UI event sequence
+    const eventTypes = chunks.map((c) => c.type)
+
+    // Should start with RUN_STARTED
+    expect(eventTypes[0]).toBe('RUN_STARTED')
+
+    // Should have TEXT_MESSAGE_START before TEXT_MESSAGE_CONTENT
+    const textStartIndex = eventTypes.indexOf('TEXT_MESSAGE_START')
+    const textContentIndex = eventTypes.indexOf('TEXT_MESSAGE_CONTENT')
+    expect(textStartIndex).toBeGreaterThan(-1)
+    expect(textContentIndex).toBeGreaterThan(textStartIndex)
+
+    // Should have TEXT_MESSAGE_END before RUN_FINISHED
+    const textEndIndex = eventTypes.indexOf('TEXT_MESSAGE_END')
+    const runFinishedIndex = eventTypes.indexOf('RUN_FINISHED')
+    expect(textEndIndex).toBeGreaterThan(-1)
+    expect(runFinishedIndex).toBeGreaterThan(textEndIndex)
+
+    // Verify RUN_FINISHED has proper data
+    const runFinishedChunk = chunks.find((c) => c.type === 'RUN_FINISHED')
+    if (runFinishedChunk?.type === 'RUN_FINISHED') {
+      expect(runFinishedChunk.finishReason).toBe('stop')
+      expect(runFinishedChunk.usage).toBeDefined()
+    }
+  })
+
+  it('emits STEP_STARTED and STEP_FINISHED for reasoning content', async () => {
+    const streamChunks = [
+      {
+        id: 'chatcmpl-123',
+        model: 'openai/o1-preview',
+        choices: [
+          {
+            delta: {
+              reasoningDetails: [
+                {
+                  type: 'reasoning.text',
+                  text: 'Let me think about this...',
+                },
+              ],
+            },
+            finishReason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-123',
+        model: 'openai/o1-preview',
+        choices: [
+          {
+            delta: { content: 'The answer is 42.' },
+            finishReason: null,
+          },
+        ],
+      },
+      {
+        id: 'chatcmpl-123',
+        model: 'openai/o1-preview',
+        choices: [
+          {
+            delta: {},
+            finishReason: 'stop',
+          },
+        ],
+        usage: {
+          promptTokens: 10,
+          completionTokens: 20,
+          totalTokens: 30,
+        },
+      },
+    ]
+
+    setupMockSdkClient(streamChunks)
+    const adapter = createAdapter()
+    const chunks: Array<StreamChunk> = []
+
+    for await (const chunk of adapter.chatStream({
+      model: 'openai/o1-preview',
+      messages: [{ role: 'user', content: 'What is the meaning of life?' }],
+    })) {
+      chunks.push(chunk)
+    }
+
+    // Check for STEP_STARTED event
+    const stepStartedChunk = chunks.find((c) => c.type === 'STEP_STARTED')
+    expect(stepStartedChunk).toBeDefined()
+    if (stepStartedChunk?.type === 'STEP_STARTED') {
+      expect(stepStartedChunk.stepId).toBeDefined()
+      expect(stepStartedChunk.stepType).toBe('thinking')
+    }
 
-    if (chunks[0] && chunks[0].type === 'error') {
-      expect(chunks[0].error.message).toBe('Invalid API key')
+    // Check for STEP_FINISHED event
+    const stepFinishedChunks = chunks.filter((c) => c.type === 'STEP_FINISHED')
+    expect(stepFinishedChunks.length).toBeGreaterThan(0)
+    const stepFinishedChunk = stepFinishedChunks[0]
+    if (stepFinishedChunk?.type === 'STEP_FINISHED') {
+      expect(stepFinishedChunk.stepId).toBeDefined()
+      expect(stepFinishedChunk.delta).toBe('Let me think about this...')
     }
   })
 })
diff --git a/packages/typescript/ai-preact/src/use-chat.ts b/packages/typescript/ai-preact/src/use-chat.ts
index c3f0f208..fc375864 100644
--- a/packages/typescript/ai-preact/src/use-chat.ts
+++ b/packages/typescript/ai-preact/src/use-chat.ts
@@ -67,6 +67,12 @@ export function useChat<TTools extends ReadonlyArray<AnyClientTool> = any>(
     })
   }, [clientId])
 
+  // Sync body changes to the client
+  // This allows dynamic body values (like model selection) to be updated without recreating the client
+  useEffect(() => {
+    client.updateOptions({ body: options.body })
+  }, [client, options.body])
+
   // Sync initial messages on mount only
   // Note: initialMessages are passed to ChatClient constructor, but we also
   // set them here to ensure Preact state is in sync
diff --git a/packages/typescript/ai-react/src/use-chat.ts b/packages/typescript/ai-react/src/use-chat.ts
index f9511e41..4b097f52 100644
--- a/packages/typescript/ai-react/src/use-chat.ts
+++ b/packages/typescript/ai-react/src/use-chat.ts
@@ -66,6 +66,12 @@ export function useChat<TTools extends ReadonlyArray<AnyClientTool> = any>(
     })
   }, [clientId])
 
+  // Sync body changes to the client
+  // This allows dynamic body values (like model selection) to be updated without recreating the client
+  useEffect(() => {
+    client.updateOptions({ body: options.body })
+  }, [client, options.body])
+
   // Sync initial messages on mount only
   // Note: initialMessages are passed to ChatClient constructor, but we also
   // set them here to ensure React state is in sync
diff --git a/packages/typescript/ai-solid/src/use-chat.ts b/packages/typescript/ai-solid/src/use-chat.ts
index 2a15fb37..54dc3a69 100644
--- a/packages/typescript/ai-solid/src/use-chat.ts
+++ b/packages/typescript/ai-solid/src/use-chat.ts
@@ -50,6 +50,13 @@ export function useChat<TTools extends ReadonlyArray<AnyClientTool> = any>(
     // Connection and other options are captured at creation time
   }, [clientId])
 
+  // Sync body changes to the client
+  // This allows dynamic body values (like model selection) to be updated without recreating the client
+  createEffect(() => {
+    const currentBody = options.body
+    client().updateOptions({ body: currentBody })
+  })
+
   // Sync initial messages on mount only
   // Note: initialMessages are passed to ChatClient constructor, but we also
   // set them here to ensure React state is in sync
diff --git a/packages/typescript/ai-svelte/src/create-chat.svelte.ts b/packages/typescript/ai-svelte/src/create-chat.svelte.ts
index c4081d27..e860afb9 100644
--- a/packages/typescript/ai-svelte/src/create-chat.svelte.ts
+++ b/packages/typescript/ai-svelte/src/create-chat.svelte.ts
@@ -115,6 +115,10 @@ export function createChat<TTools extends ReadonlyArray<AnyClientTool> = any>(
     await client.addToolApprovalResponse(response)
   }
 
+  const updateBody = (newBody: Record<string, any>) => {
+    client.updateOptions({ body: newBody })
+  }
+
   // Return the chat interface with reactive getters
   // Using getters allows Svelte to track reactivity without needing $ prefix
   return {
@@ -135,5 +139,6 @@ export function createChat<TTools extends ReadonlyArray<AnyClientTool> = any>(
     clear,
     addToolResult,
     addToolApprovalResponse,
+    updateBody,
   }
 }
diff --git a/packages/typescript/ai-svelte/src/types.ts b/packages/typescript/ai-svelte/src/types.ts
index 5d07e34f..e8e36191 100644
--- a/packages/typescript/ai-svelte/src/types.ts
+++ b/packages/typescript/ai-svelte/src/types.ts
@@ -96,6 +96,11 @@ export interface CreateChatReturn<
    * Clear all messages
    */
   clear: () => void
+
+  /**
+   * Update the body sent with requests (e.g., for changing model selection)
+   */
+  updateBody: (body: Record<string, any>) => void
 }
 
 // Note: createChatClientOptions and InferChatMessages are now in @tanstack/ai-client
diff --git a/packages/typescript/ai-vue/src/use-chat.ts b/packages/typescript/ai-vue/src/use-chat.ts
index f190d0ee..eaad3c0f 100644
--- a/packages/typescript/ai-vue/src/use-chat.ts
+++ b/packages/typescript/ai-vue/src/use-chat.ts
@@ -1,5 +1,5 @@
 import { ChatClient } from '@tanstack/ai-client'
-import { onScopeDispose, readonly, shallowRef, useId } from 'vue'
+import { onScopeDispose, readonly, shallowRef, useId, watch } from 'vue'
 import type { AnyClientTool, ModelMessage } from '@tanstack/ai'
 import type { UIMessage, UseChatOptions, UseChatReturn } from './types'
 
@@ -38,6 +38,15 @@ export function useChat<TTools extends ReadonlyArray<AnyClientTool> = any>(
     },
   })
 
+  // Sync body changes to the client
+  // This allows dynamic body values (like model selection) to be updated without recreating the client
+  watch(
+    () => options.body,
+    (newBody) => {
+      client.updateOptions({ body: newBody })
+    },
+  )
+
   // Cleanup on unmount: stop any in-flight requests
   // Note: client.stop() is safe to call even if nothing is in progress
   onScopeDispose(() => {
diff --git a/packages/typescript/ai/src/activities/chat/index.ts b/packages/typescript/ai/src/activities/chat/index.ts
index e60f8735..feb5ef99 100644
--- a/packages/typescript/ai/src/activities/chat/index.ts
+++ b/packages/typescript/ai/src/activities/chat/index.ts
@@ -23,14 +23,18 @@ import type { AnyTextAdapter } from './adapter'
 import type {
   AgentLoopStrategy,
   ConstrainedModelMessage,
-  DoneStreamChunk,
   InferSchemaType,
   ModelMessage,
+  RunFinishedEvent,
   SchemaInput,
   StreamChunk,
+  TextMessageContentEvent,
   TextOptions,
   Tool,
   ToolCall,
+  ToolCallArgsEvent,
+  ToolCallEndEvent,
+  ToolCallStartEvent,
 } from '../../types'
 
 // ===========================
@@ -215,7 +219,7 @@ class TextEngine<
   private accumulatedContent = ''
   private eventOptions?: Record<string, unknown>
   private eventToolNames?: Array<string>
-  private doneChunk: DoneStreamChunk | null = null
+  private finishedEvent: RunFinishedEvent | null = null
   private shouldEmitStreamEnd = true
   private earlyTermination = false
   private toolPhase: ToolPhaseResult = 'continue'
@@ -347,7 +351,7 @@ class TextEngine<
       content: this.accumulatedContent,
       messageId: this.currentMessageId || undefined,
       finishReason: this.lastFinishReason || undefined,
-      usage: this.doneChunk?.usage,
+      usage: this.finishedEvent?.usage,
       duration: now - this.streamStartTime,
       timestamp: now,
     })
@@ -372,7 +376,7 @@ class TextEngine<
   private beginIteration(): void {
     this.currentMessageId = this.createId('msg')
     this.accumulatedContent = ''
-    this.doneChunk = null
+    this.finishedEvent = null
 
     const baseContext = this.buildTextEventContext()
     aiEventClient.emit('text:message:created', {
@@ -428,70 +432,94 @@ class TextEngine<
 
   private handleStreamChunk(chunk: StreamChunk): void {
     switch (chunk.type) {
-      case 'content':
-        this.handleContentChunk(chunk)
+      // AG-UI Events
+      case 'TEXT_MESSAGE_CONTENT':
+        this.handleTextMessageContentEvent(chunk)
         break
-      case 'tool_call':
-        this.handleToolCallChunk(chunk)
+      case 'TOOL_CALL_START':
+        this.handleToolCallStartEvent(chunk)
         break
-      case 'tool_result':
-        this.handleToolResultChunk(chunk)
+      case 'TOOL_CALL_ARGS':
+        this.handleToolCallArgsEvent(chunk)
         break
-      case 'done':
-        this.handleDoneChunk(chunk)
+      case 'TOOL_CALL_END':
+        this.handleToolCallEndEvent(chunk)
         break
-      case 'error':
-        this.handleErrorChunk(chunk)
+      case 'RUN_FINISHED':
+        this.handleRunFinishedEvent(chunk)
         break
-      case 'thinking':
-        this.handleThinkingChunk(chunk)
+      case 'RUN_ERROR':
+        this.handleRunErrorEvent(chunk)
         break
+      case 'STEP_FINISHED':
+        this.handleStepFinishedEvent(chunk)
+        break
+
       default:
+        // RUN_STARTED, TEXT_MESSAGE_START, TEXT_MESSAGE_END, STEP_STARTED,
+        // STATE_SNAPSHOT, STATE_DELTA, CUSTOM
+        // - no special handling needed in chat activity
         break
     }
   }
 
-  private handleContentChunk(chunk: Extract<StreamChunk, { type: 'content' }>) {
-    this.accumulatedContent = chunk.content
+  // ===========================
+  // AG-UI Event Handlers
+  // ===========================
+
+  private handleTextMessageContentEvent(chunk: TextMessageContentEvent): void {
+    if (chunk.content) {
+      this.accumulatedContent = chunk.content
+    } else {
+      this.accumulatedContent += chunk.delta
+    }
     aiEventClient.emit('text:chunk:content', {
       ...this.buildTextEventContext(),
       messageId: this.currentMessageId || undefined,
-      content: chunk.content,
+      content: this.accumulatedContent,
       delta: chunk.delta,
       timestamp: Date.now(),
     })
   }
 
-  private handleToolCallChunk(
-    chunk: Extract<StreamChunk, { type: 'tool_call' }>,
-  ): void {
-    this.toolCallManager.addToolCallChunk(chunk)
+  private handleToolCallStartEvent(chunk: ToolCallStartEvent): void {
+    this.toolCallManager.addToolCallStartEvent(chunk)
     aiEventClient.emit('text:chunk:tool-call', {
       ...this.buildTextEventContext(),
       messageId: this.currentMessageId || undefined,
-      toolCallId: chunk.toolCall.id,
-      toolName: chunk.toolCall.function.name,
-      index: chunk.index,
-      arguments: chunk.toolCall.function.arguments,
+      toolCallId: chunk.toolCallId,
+      toolName: chunk.toolName,
+      index: chunk.index ?? 0,
+      arguments: '',
       timestamp: Date.now(),
     })
   }
 
-  private handleToolResultChunk(
-    chunk: Extract<StreamChunk, { type: 'tool_result' }>,
-  ): void {
+  private handleToolCallArgsEvent(chunk: ToolCallArgsEvent): void {
+    this.toolCallManager.addToolCallArgsEvent(chunk)
+    aiEventClient.emit('text:chunk:tool-call', {
+      ...this.buildTextEventContext(),
+      messageId: this.currentMessageId || undefined,
+      toolCallId: chunk.toolCallId,
+      toolName: '',
+      index: 0,
+      arguments: chunk.delta,
+      timestamp: Date.now(),
+    })
+  }
+
+  private handleToolCallEndEvent(chunk: ToolCallEndEvent): void {
+    this.toolCallManager.completeToolCall(chunk)
     aiEventClient.emit('text:chunk:tool-result', {
       ...this.buildTextEventContext(),
       messageId: this.currentMessageId || undefined,
       toolCallId: chunk.toolCallId,
-      result: chunk.content,
+      result: chunk.result || '',
       timestamp: Date.now(),
     })
   }
 
-  private handleDoneChunk(chunk: DoneStreamChunk): void {
-    // Don't overwrite a tool_calls finishReason with a stop finishReason
-    // This can happen when adapters send multiple done chunks
+  private handleRunFinishedEvent(chunk: RunFinishedEvent): void {
     aiEventClient.emit('text:chunk:done', {
       ...this.buildTextEventContext(),
       messageId: this.currentMessageId || undefined,
@@ -508,22 +536,22 @@ class TextEngine<
         timestamp: Date.now(),
       })
     }
+
+    // Don't overwrite a tool_calls finishReason with a stop finishReason
     if (
-      this.doneChunk?.finishReason === 'tool_calls' &&
+      this.finishedEvent?.finishReason === 'tool_calls' &&
       chunk.finishReason === 'stop'
     ) {
-      // Still emit the event and update lastFinishReason, but don't overwrite doneChunk
       this.lastFinishReason = chunk.finishReason
-
       return
     }
 
-    this.doneChunk = chunk
+    this.finishedEvent = chunk
     this.lastFinishReason = chunk.finishReason
   }
 
-  private handleErrorChunk(
-    chunk: Extract<StreamChunk, { type: 'error' }>,
+  private handleRunErrorEvent(
+    chunk: Extract<StreamChunk, { type: 'RUN_ERROR' }>,
   ): void {
     aiEventClient.emit('text:chunk:error', {
       ...this.buildTextEventContext(),
@@ -535,16 +563,19 @@ class TextEngine<
     this.shouldEmitStreamEnd = false
   }
 
-  private handleThinkingChunk(
-    chunk: Extract<StreamChunk, { type: 'thinking' }>,
+  private handleStepFinishedEvent(
+    chunk: Extract<StreamChunk, { type: 'STEP_FINISHED' }>,
   ): void {
-    aiEventClient.emit('text:chunk:thinking', {
-      ...this.buildTextEventContext(),
-      messageId: this.currentMessageId || undefined,
-      content: chunk.content,
-      delta: chunk.delta,
-      timestamp: Date.now(),
-    })
+    // Handle thinking/reasoning content from STEP_FINISHED events
+    if (chunk.content || chunk.delta) {
+      aiEventClient.emit('text:chunk:thinking', {
+        ...this.buildTextEventContext(),
+        messageId: this.currentMessageId || undefined,
+        content: chunk.content || '',
+        delta: chunk.delta,
+        timestamp: Date.now(),
+      })
+    }
   }
 
   private async *checkForPendingToolCalls(): AsyncGenerator<
@@ -557,7 +588,7 @@ class TextEngine<
       return 'continue'
     }
 
-    const doneChunk = this.createSyntheticDoneChunk()
+    const finishEvent = this.createSyntheticFinishedEvent()
 
     const { approvals, clientToolResults } = this.collectClientState()
 
@@ -574,14 +605,14 @@ class TextEngine<
     ) {
       for (const chunk of this.emitApprovalRequests(
         executionResult.needsApproval,
-        doneChunk,
+        finishEvent,
       )) {
         yield chunk
       }
 
       for (const chunk of this.emitClientToolInputs(
         executionResult.needsClientExecution,
-        doneChunk,
+        finishEvent,
       )) {
         yield chunk
       }
@@ -592,7 +623,7 @@ class TextEngine<
 
     const toolResultChunks = this.emitToolResults(
       executionResult.results,
-      doneChunk,
+      finishEvent,
     )
 
     for (const chunk of toolResultChunks) {
@@ -609,9 +640,9 @@ class TextEngine<
     }
 
     const toolCalls = this.toolCallManager.getToolCalls()
-    const doneChunk = this.doneChunk
+    const finishEvent = this.finishedEvent
 
-    if (!doneChunk || toolCalls.length === 0) {
+    if (!finishEvent || toolCalls.length === 0) {
       this.setToolPhase('stop')
       return
     }
@@ -633,14 +664,14 @@ class TextEngine<
     ) {
       for (const chunk of this.emitApprovalRequests(
         executionResult.needsApproval,
-        doneChunk,
+        finishEvent,
       )) {
         yield chunk
       }
 
       for (const chunk of this.emitClientToolInputs(
         executionResult.needsClientExecution,
-        doneChunk,
+        finishEvent,
       )) {
         yield chunk
       }
@@ -651,7 +682,7 @@ class TextEngine<
 
     const toolResultChunks = this.emitToolResults(
       executionResult.results,
-      doneChunk,
+      finishEvent,
     )
 
     for (const chunk of toolResultChunks) {
@@ -665,7 +696,7 @@ class TextEngine<
 
   private shouldExecuteToolPhase(): boolean {
     return (
-      this.doneChunk?.finishReason === 'tool_calls' &&
+      this.finishedEvent?.finishReason === 'tool_calls' &&
       this.tools.length > 0 &&
       this.toolCallManager.hasToolCalls()
     )
@@ -728,7 +759,7 @@ class TextEngine<
 
   private emitApprovalRequests(
     approvals: Array<ApprovalRequest>,
-    doneChunk: DoneStreamChunk,
+    finishEvent: RunFinishedEvent,
   ): Array<StreamChunk> {
     const chunks: Array<StreamChunk> = []
 
@@ -743,17 +774,20 @@ class TextEngine<
         timestamp: Date.now(),
       })
 
+      // Emit a CUSTOM event for approval requests
       chunks.push({
-        type: 'approval-requested',
-        id: doneChunk.id,
-        model: doneChunk.model,
+        type: 'CUSTOM',
         timestamp: Date.now(),
-        toolCallId: approval.toolCallId,
-        toolName: approval.toolName,
-        input: approval.input,
-        approval: {
-          id: approval.approvalId,
-          needsApproval: true,
+        model: finishEvent.model,
+        name: 'approval-requested',
+        data: {
+          toolCallId: approval.toolCallId,
+          toolName: approval.toolName,
+          input: approval.input,
+          approval: {
+            id: approval.approvalId,
+            needsApproval: true,
+          },
         },
       })
     }
@@ -763,7 +797,7 @@ class TextEngine<
 
   private emitClientToolInputs(
     clientRequests: Array<ClientToolRequest>,
-    doneChunk: DoneStreamChunk,
+    finishEvent: RunFinishedEvent,
   ): Array<StreamChunk> {
     const chunks: Array<StreamChunk> = []
 
@@ -777,14 +811,17 @@ class TextEngine<
         timestamp: Date.now(),
       })
 
+      // Emit a CUSTOM event for client tool inputs
       chunks.push({
-        type: 'tool-input-available',
-        id: doneChunk.id,
-        model: doneChunk.model,
+        type: 'CUSTOM',
         timestamp: Date.now(),
-        toolCallId: clientTool.toolCallId,
-        toolName: clientTool.toolName,
-        input: clientTool.input,
+        model: finishEvent.model,
+        name: 'tool-input-available',
+        data: {
+          toolCallId: clientTool.toolCallId,
+          toolName: clientTool.toolName,
+          input: clientTool.input,
+        },
       })
     }
 
@@ -793,7 +830,7 @@ class TextEngine<
 
   private emitToolResults(
     results: Array<ToolResult>,
-    doneChunk: DoneStreamChunk,
+    finishEvent: RunFinishedEvent,
   ): Array<StreamChunk> {
     const chunks: Array<StreamChunk> = []
 
@@ -809,16 +846,16 @@ class TextEngine<
       })
 
       const content = JSON.stringify(result.result)
-      const chunk: Extract<StreamChunk, { type: 'tool_result' }> = {
-        type: 'tool_result',
-        id: doneChunk.id,
-        model: doneChunk.model,
+
+      // Emit TOOL_CALL_END event
+      chunks.push({
+        type: 'TOOL_CALL_END',
         timestamp: Date.now(),
+        model: finishEvent.model,
         toolCallId: result.toolCallId,
-        content,
-      }
-
-      chunks.push(chunk)
+        toolName: result.toolName,
+        result: content,
+      })
 
       this.messages = [
         ...this.messages,
@@ -863,10 +900,10 @@ class TextEngine<
     return pending
   }
 
-  private createSyntheticDoneChunk(): DoneStreamChunk {
+  private createSyntheticFinishedEvent(): RunFinishedEvent {
     return {
-      type: 'done',
-      id: this.createId('pending'),
+      type: 'RUN_FINISHED',
+      runId: this.createId('pending'),
       model: this.params.model,
       timestamp: Date.now(),
       finishReason: 'tool_calls',
diff --git a/packages/typescript/ai/src/activities/chat/stream/index.ts b/packages/typescript/ai/src/activities/chat/stream/index.ts
index eb629a65..ff7cb980 100644
--- a/packages/typescript/ai/src/activities/chat/stream/index.ts
+++ b/packages/typescript/ai/src/activities/chat/stream/index.ts
@@ -6,11 +6,7 @@
 
 // Core processor
 export { StreamProcessor, createReplayStream } from './processor'
-export type {
-  StreamProcessorEvents,
-  StreamProcessorHandlers,
-  StreamProcessorOptions,
-} from './processor'
+export type { StreamProcessorEvents, StreamProcessorOptions } from './processor'
 
 // Strategies
 export {
diff --git a/packages/typescript/ai/src/activities/chat/stream/processor.ts b/packages/typescript/ai/src/activities/chat/stream/processor.ts
index 8873d124..0f480f9d 100644
--- a/packages/typescript/ai/src/activities/chat/stream/processor.ts
+++ b/packages/typescript/ai/src/activities/chat/stream/processor.ts
@@ -78,67 +78,13 @@ export interface StreamProcessorEvents {
   onThinkingUpdate?: (messageId: string, content: string) => void
 }
 
-/**
- * Legacy handlers for backward compatibility
- * These are the old callback-style handlers
- */
-export interface StreamProcessorHandlers {
-  onTextUpdate?: (content: string) => void
-  onThinkingUpdate?: (content: string) => void
-
-  // Tool call lifecycle handlers
-  onToolCallStart?: (index: number, id: string, name: string) => void
-  onToolCallDelta?: (index: number, args: string) => void
-  onToolCallComplete?: (
-    index: number,
-    id: string,
-    name: string,
-    args: string,
-  ) => void
-  onToolCallStateChange?: (
-    index: number,
-    id: string,
-    name: string,
-    state: ToolCallState,
-    args: string,
-    parsedArgs?: any,
-  ) => void
-
-  // Tool result handlers
-  onToolResultStateChange?: (
-    toolCallId: string,
-    content: string,
-    state: ToolResultState,
-    error?: string,
-  ) => void
-
-  // Approval/client tool handlers
-  onApprovalRequested?: (
-    toolCallId: string,
-    toolName: string,
-    input: any,
-    approvalId: string,
-  ) => void
-  onToolInputAvailable?: (
-    toolCallId: string,
-    toolName: string,
-    input: any,
-  ) => void
-
-  // Stream lifecycle
-  onStreamEnd?: (content: string, toolCalls?: Array<ToolCall>) => void
-  onError?: (error: { message: string; code?: string }) => void
-}
-
 /**
  * Options for StreamProcessor
  */
 export interface StreamProcessorOptions {
   chunkStrategy?: ChunkStrategy
-  /** New event-driven handlers */
+  /** Event-driven handlers */
   events?: StreamProcessorEvents
-  /** Legacy callback handlers (for backward compatibility) */
-  handlers?: StreamProcessorHandlers
   jsonParser?: {
     parse: (jsonString: string) => any
   }
@@ -168,7 +114,6 @@ export interface StreamProcessorOptions {
 export class StreamProcessor {
   private chunkStrategy: ChunkStrategy
   private events: StreamProcessorEvents
-  private handlers: StreamProcessorHandlers
   private jsonParser: { parse: (jsonString: string) => any }
   private recordingEnabled: boolean
 
@@ -197,7 +142,6 @@ export class StreamProcessor {
   constructor(options: StreamProcessorOptions = {}) {
     this.chunkStrategy = options.chunkStrategy || new ImmediateStrategy()
     this.events = options.events || {}
-    this.handlers = options.handlers || {}
     this.jsonParser = options.jsonParser || defaultJSONParser
     this.recordingEnabled = options.recording ?? false
 
@@ -423,49 +367,51 @@ export class StreamProcessor {
     }
 
     switch (chunk.type) {
-      case 'content':
-        this.handleContentChunk(chunk)
+      // AG-UI Events
+      case 'TEXT_MESSAGE_CONTENT':
+        this.handleTextMessageContentEvent(chunk)
         break
 
-      case 'tool_call':
-        this.handleToolCallChunk(chunk)
+      case 'TOOL_CALL_START':
+        this.handleToolCallStartEvent(chunk)
         break
 
-      case 'tool_result':
-        this.handleToolResultChunk(chunk)
+      case 'TOOL_CALL_ARGS':
+        this.handleToolCallArgsEvent(chunk)
         break
 
-      case 'done':
-        this.handleDoneChunk(chunk)
+      case 'TOOL_CALL_END':
+        this.handleToolCallEndEvent(chunk)
         break
 
-      case 'error':
-        this.handleErrorChunk(chunk)
+      case 'RUN_FINISHED':
+        this.handleRunFinishedEvent(chunk)
         break
 
-      case 'thinking':
-        this.handleThinkingChunk(chunk)
+      case 'RUN_ERROR':
+        this.handleRunErrorEvent(chunk)
         break
 
-      case 'approval-requested':
-        this.handleApprovalRequestedChunk(chunk)
+      case 'STEP_FINISHED':
+        this.handleStepFinishedEvent(chunk)
         break
 
-      case 'tool-input-available':
-        this.handleToolInputAvailableChunk(chunk)
+      case 'CUSTOM':
+        this.handleCustomEvent(chunk)
         break
 
       default:
-        // Unknown chunk type - ignore
+        // RUN_STARTED, TEXT_MESSAGE_START, TEXT_MESSAGE_END, STEP_STARTED,
+        // STATE_SNAPSHOT, STATE_DELTA - no special handling needed
         break
     }
   }
 
   /**
-   * Handle a content chunk
+   * Handle TEXT_MESSAGE_CONTENT event
    */
-  private handleContentChunk(
-    chunk: Extract<StreamChunk, { type: 'content' }>,
+  private handleTextMessageContentEvent(
+    chunk: Extract<StreamChunk, { type: 'TEXT_MESSAGE_CONTENT' }>,
   ): void {
     // Content arriving means all current tool calls are complete
     this.completeAllToolCalls()
@@ -495,7 +441,7 @@ export class StreamProcessor {
     // Prefer delta over content - delta is the incremental change
     if (chunk.delta !== '') {
       nextText = currentText + chunk.delta
-    } else if (chunk.content !== '') {
+    } else if (chunk.content && chunk.content !== '') {
       // Fallback: use content if delta is not provided
       if (chunk.content.startsWith(currentText)) {
         nextText = chunk.content
@@ -512,8 +458,7 @@ export class StreamProcessor {
     this.totalTextContent += textDelta
 
     // Use delta for chunk strategy if available
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    const chunkPortion = chunk.delta ?? chunk.content ?? ''
+    const chunkPortion = chunk.delta || chunk.content || ''
     const shouldEmit = this.chunkStrategy.shouldEmit(
       chunkPortion,
       this.currentSegmentText,
@@ -524,100 +469,75 @@ export class StreamProcessor {
   }
 
   /**
-   * Handle a tool call chunk
+   * Handle TOOL_CALL_START event
    */
-  private handleToolCallChunk(
-    chunk: Extract<StreamChunk, { type: 'tool_call' }>,
+  private handleToolCallStartEvent(
+    chunk: Extract<StreamChunk, { type: 'TOOL_CALL_START' }>,
   ): void {
     // Mark that we've seen tool calls since the last text segment
     this.hasToolCallsSinceTextStart = true
 
-    const toolCallId = chunk.toolCall.id
+    const toolCallId = chunk.toolCallId
     const existingToolCall = this.toolCalls.get(toolCallId)
 
     if (!existingToolCall) {
       // New tool call starting
-      const initialState: ToolCallState = chunk.toolCall.function.arguments
-        ? 'input-streaming'
-        : 'awaiting-input'
+      const initialState: ToolCallState = 'awaiting-input'
 
       const newToolCall: InternalToolCallState = {
-        id: chunk.toolCall.id,
-        name: chunk.toolCall.function.name,
-        arguments: chunk.toolCall.function.arguments || '',
+        id: chunk.toolCallId,
+        name: chunk.toolName,
+        arguments: '',
         state: initialState,
         parsedArguments: undefined,
-        index: chunk.index,
-      }
-
-      // Try to parse the arguments
-      if (chunk.toolCall.function.arguments) {
-        newToolCall.parsedArguments = this.jsonParser.parse(
-          chunk.toolCall.function.arguments,
-        )
+        index: chunk.index ?? this.toolCalls.size,
       }
 
       this.toolCalls.set(toolCallId, newToolCall)
       this.toolCallOrder.push(toolCallId)
 
-      // Get actual index for this tool call (based on order)
-      const actualIndex = this.toolCallOrder.indexOf(toolCallId)
-
-      // Emit legacy lifecycle event
-      this.handlers.onToolCallStart?.(
-        actualIndex,
-        chunk.toolCall.id,
-        chunk.toolCall.function.name,
-      )
-
-      // Emit legacy state change event
-      this.handlers.onToolCallStateChange?.(
-        actualIndex,
-        chunk.toolCall.id,
-        chunk.toolCall.function.name,
-        initialState,
-        chunk.toolCall.function.arguments || '',
-        newToolCall.parsedArguments,
-      )
-
-      // Emit initial delta
-      if (chunk.toolCall.function.arguments) {
-        this.handlers.onToolCallDelta?.(
-          actualIndex,
-          chunk.toolCall.function.arguments,
-        )
-      }
-
       // Update UIMessage
       if (this.currentAssistantMessageId) {
         this.messages = updateToolCallPart(
           this.messages,
           this.currentAssistantMessageId,
           {
-            id: chunk.toolCall.id,
-            name: chunk.toolCall.function.name,
-            arguments: chunk.toolCall.function.arguments || '',
+            id: chunk.toolCallId,
+            name: chunk.toolName,
+            arguments: '',
             state: initialState,
           },
         )
         this.emitMessagesChange()
 
-        // Emit new granular event
+        // Emit granular event
         this.events.onToolCallStateChange?.(
           this.currentAssistantMessageId,
-          chunk.toolCall.id,
+          chunk.toolCallId,
           initialState,
-          chunk.toolCall.function.arguments || '',
+          '',
         )
       }
-    } else {
-      // Continuing existing tool call
+    }
+  }
+
+  /**
+   * Handle TOOL_CALL_ARGS event
+   */
+  private handleToolCallArgsEvent(
+    chunk: Extract<StreamChunk, { type: 'TOOL_CALL_ARGS' }>,
+  ): void {
+    const toolCallId = chunk.toolCallId
+    const existingToolCall = this.toolCalls.get(toolCallId)
+
+    if (existingToolCall) {
       const wasAwaitingInput = existingToolCall.state === 'awaiting-input'
 
-      existingToolCall.arguments += chunk.toolCall.function.arguments || ''
+      // Accumulate arguments from delta
+      existingToolCall.arguments += chunk.delta || ''
 
       // Update state
-      if (wasAwaitingInput && chunk.toolCall.function.arguments) {
+      if (wasAwaitingInput && chunk.delta) {
         existingToolCall.state = 'input-streaming'
       }
 
@@ -626,27 +546,6 @@ export class StreamProcessor {
         existingToolCall.arguments,
       )
 
-      // Get actual index for this tool call
-      const actualIndex = this.toolCallOrder.indexOf(toolCallId)
-
-      // Emit legacy state change event
-      this.handlers.onToolCallStateChange?.(
-        actualIndex,
-        existingToolCall.id,
-        existingToolCall.name,
-        existingToolCall.state,
-        existingToolCall.arguments,
-        existingToolCall.parsedArguments,
-      )
-
-      // Emit delta
-      if (chunk.toolCall.function.arguments) {
-        this.handlers.onToolCallDelta?.(
-          actualIndex,
-          chunk.toolCall.function.arguments,
-        )
-      }
-
       // Update UIMessage
       if (this.currentAssistantMessageId) {
         this.messages = updateToolCallPart(
@@ -661,7 +560,7 @@ export class StreamProcessor {
         )
         this.emitMessagesChange()
 
-        // Emit new granular event
+        // Emit granular event
         this.events.onToolCallStateChange?.(
           this.currentAssistantMessageId,
           existingToolCall.id,
@@ -673,27 +572,20 @@ export class StreamProcessor {
   }
 
   /**
-   * Handle a tool result chunk
+   * Handle TOOL_CALL_END event
    */
-  private handleToolResultChunk(
-    chunk: Extract<StreamChunk, { type: 'tool_result' }>,
+  private handleToolCallEndEvent(
+    chunk: Extract<StreamChunk, { type: 'TOOL_CALL_END' }>,
   ): void {
     const state: ToolResultState = 'complete'
 
-    // Emit legacy handler
-    this.handlers.onToolResultStateChange?.(
-      chunk.toolCallId,
-      chunk.content,
-      state,
-    )
-
     // Update UIMessage if we have a current assistant message
-    if (this.currentAssistantMessageId) {
+    if (this.currentAssistantMessageId && chunk.result) {
       this.messages = updateToolResultPart(
         this.messages,
         this.currentAssistantMessageId,
         chunk.toolCallId,
-        chunk.content,
+        chunk.result,
         state,
       )
       this.emitMessagesChange()
@@ -701,32 +593,31 @@ export class StreamProcessor {
   }
 
   /**
-   * Handle a done chunk
+   * Handle RUN_FINISHED event
    */
-  private handleDoneChunk(chunk: Extract<StreamChunk, { type: 'done' }>): void {
+  private handleRunFinishedEvent(
+    chunk: Extract<StreamChunk, { type: 'RUN_FINISHED' }>,
+  ): void {
     this.finishReason = chunk.finishReason
     this.isDone = true
     this.completeAllToolCalls()
   }
 
   /**
-   * Handle an error chunk
+   * Handle RUN_ERROR event
    */
-  private handleErrorChunk(
-    chunk: Extract<StreamChunk, { type: 'error' }>,
+  private handleRunErrorEvent(
+    chunk: Extract<StreamChunk, { type: 'RUN_ERROR' }>,
   ): void {
-    // Emit legacy handler
-    this.handlers.onError?.(chunk.error)
-
-    // Emit new event
-    this.events.onError?.(new Error(chunk.error.message))
+    // Emit error event
+    this.events.onError?.(new Error(chunk.error.message || 'An error occurred'))
   }
 
   /**
-   * Handle a thinking chunk
+   * Handle STEP_FINISHED event (for thinking/reasoning content)
    */
-  private handleThinkingChunk(
-    chunk: Extract<StreamChunk, { type: 'thinking' }>,
+  private handleStepFinishedEvent(
+    chunk: Extract<StreamChunk, { type: 'STEP_FINISHED' }>,
   ): void {
     const previous = this.thinkingContent
     let nextThinking = previous
@@ -734,7 +625,7 @@ export class StreamProcessor {
     // Prefer delta over content
     if (chunk.delta && chunk.delta !== '') {
       nextThinking = previous + chunk.delta
-    } else if (chunk.content !== '') {
+    } else if (chunk.content && chunk.content !== '') {
       if (chunk.content.startsWith(previous)) {
         nextThinking = chunk.content
       } else if (previous.startsWith(chunk.content)) {
@@ -746,9 +637,6 @@ export class StreamProcessor {
 
     this.thinkingContent = nextThinking
 
-    // Emit legacy handler
-    this.handlers.onThinkingUpdate?.(this.thinkingContent)
-
     // Update UIMessage
     if (this.currentAssistantMessageId) {
       this.messages = updateThinkingPart(
@@ -758,7 +646,7 @@ export class StreamProcessor {
       )
       this.emitMessagesChange()
 
-      // Emit new granular event
+      // Emit granular event
       this.events.onThinkingUpdate?.(
         this.currentAssistantMessageId,
         this.thinkingContent,
@@ -767,69 +655,68 @@ export class StreamProcessor {
   }
 
   /**
-   * Handle an approval-requested chunk
+   * Handle CUSTOM event
+   * Handles special custom events like 'tool-input-available' for client-side tool execution
+   * and 'approval-requested' for tool approval flows
    */
-  private handleApprovalRequestedChunk(
-    chunk: Extract<StreamChunk, { type: 'approval-requested' }>,
+  private handleCustomEvent(
+    chunk: Extract<StreamChunk, { type: 'CUSTOM' }>,
   ): void {
-    // Emit legacy handler
-    this.handlers.onApprovalRequested?.(
-      chunk.toolCallId,
-      chunk.toolName,
-      chunk.input,
-      chunk.approval.id,
-    )
+    // Handle client tool input availability - trigger client-side execution
+    if (chunk.name === 'tool-input-available' && chunk.data) {
+      const { toolCallId, toolName, input } = chunk.data as {
+        toolCallId: string
+        toolName: string
+        input: any
+      }
 
-    // Update UIMessage with approval metadata
-    if (this.currentAssistantMessageId) {
-      this.messages = updateToolCallApproval(
-        this.messages,
-        this.currentAssistantMessageId,
-        chunk.toolCallId,
-        chunk.approval.id,
-      )
-      this.emitMessagesChange()
+      // Emit onToolCall event for the client to execute the tool
+      this.events.onToolCall?.({
+        toolCallId,
+        toolName,
+        input,
+      })
     }
 
-    // Emit new event
-    this.events.onApprovalRequest?.({
-      toolCallId: chunk.toolCallId,
-      toolName: chunk.toolName,
-      input: chunk.input,
-      approvalId: chunk.approval.id,
-    })
-  }
+    // Handle approval requests
+    if (chunk.name === 'approval-requested' && chunk.data) {
+      const { toolCallId, toolName, input, approval } = chunk.data as {
+        toolCallId: string
+        toolName: string
+        input: any
+        approval: { id: string; needsApproval: boolean }
+      }
 
-  /**
-   * Handle a tool-input-available chunk
-   */
-  private handleToolInputAvailableChunk(
-    chunk: Extract<StreamChunk, { type: 'tool-input-available' }>,
-  ): void {
-    // Emit legacy handler
-    this.handlers.onToolInputAvailable?.(
-      chunk.toolCallId,
-      chunk.toolName,
-      chunk.input,
-    )
+      // Update the tool call part with approval state
+      if (this.currentAssistantMessageId) {
+        this.messages = updateToolCallApproval(
+          this.messages,
+          this.currentAssistantMessageId,
+          toolCallId,
+          approval.id,
+        )
+        this.emitMessagesChange()
+      }
 
-    // Emit new event
-    this.events.onToolCall?.({
-      toolCallId: chunk.toolCallId,
-      toolName: chunk.toolName,
-      input: chunk.input,
-    })
+      // Emit approval request event
+      this.events.onApprovalRequest?.({
+        toolCallId,
+        toolName,
+        input,
+        approvalId: approval.id,
+      })
+    }
   }
 
   /**
    * Detect if an incoming content chunk represents a NEW text segment
    */
   private isNewTextSegment(
-    chunk: Extract<StreamChunk, { type: 'content' }>,
+    chunk: Extract<StreamChunk, { type: 'TEXT_MESSAGE_CONTENT' }>,
     previous: string,
   ): boolean {
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (chunk.delta !== undefined && chunk.content !== undefined) {
+    // Check if content is present (delta is always defined but may be empty string)
+    if (chunk.content !== undefined) {
       if (chunk.content.length < previous.length) {
         return true
       }
@@ -859,7 +746,7 @@ export class StreamProcessor {
    * Mark a tool call as complete and emit event
    */
   private completeToolCall(
-    index: number,
+    _index: number,
     toolCall: InternalToolCallState,
   ): void {
     toolCall.state = 'input-complete'
@@ -867,24 +754,6 @@ export class StreamProcessor {
     // Try final parse
     toolCall.parsedArguments = this.jsonParser.parse(toolCall.arguments)
 
-    // Emit legacy state change event
-    this.handlers.onToolCallStateChange?.(
-      index,
-      toolCall.id,
-      toolCall.name,
-      'input-complete',
-      toolCall.arguments,
-      toolCall.parsedArguments,
-    )
-
-    // Emit legacy complete event
-    this.handlers.onToolCallComplete?.(
-      index,
-      toolCall.id,
-      toolCall.name,
-      toolCall.arguments,
-    )
-
     // Update UIMessage
     if (this.currentAssistantMessageId) {
       this.messages = updateToolCallPart(
@@ -899,7 +768,7 @@ export class StreamProcessor {
       )
       this.emitMessagesChange()
 
-      // Emit new granular event
+      // Emit granular event
       this.events.onToolCallStateChange?.(
         this.currentAssistantMessageId,
         toolCall.id,
@@ -915,9 +784,6 @@ export class StreamProcessor {
   private emitTextUpdate(): void {
     this.lastEmittedText = this.currentSegmentText
 
-    // Emit legacy handler
-    this.handlers.onTextUpdate?.(this.currentSegmentText)
-
     // Update UIMessage
     if (this.currentAssistantMessageId) {
       this.messages = updateTextPart(
@@ -927,7 +793,7 @@ export class StreamProcessor {
       )
       this.emitMessagesChange()
 
-      // Emit new granular event
+      // Emit granular event
       this.events.onTextUpdate?.(
         this.currentAssistantMessageId,
         this.currentSegmentText,
@@ -954,14 +820,7 @@ export class StreamProcessor {
       this.emitTextUpdate()
     }
 
-    // Emit legacy stream end with total accumulated content
-    const toolCalls = this.getCompletedToolCalls()
-    this.handlers.onStreamEnd?.(
-      this.totalTextContent,
-      toolCalls.length > 0 ? toolCalls : undefined,
-    )
-
-    // Emit new stream end event
+    // Emit stream end event
     if (this.currentAssistantMessageId) {
       const assistantMessage = this.messages.find(
         (m) => m.id === this.currentAssistantMessageId,
@@ -1002,7 +861,7 @@ export class StreamProcessor {
   }
 
   /**
-   * Get current processor state (legacy)
+   * Get current processor state
    */
   getState(): ProcessorState {
     return {
diff --git a/packages/typescript/ai/src/activities/chat/tools/tool-calls.ts b/packages/typescript/ai/src/activities/chat/tools/tool-calls.ts
index 5096db42..828c1697 100644
--- a/packages/typescript/ai/src/activities/chat/tools/tool-calls.ts
+++ b/packages/typescript/ai/src/activities/chat/tools/tool-calls.ts
@@ -1,20 +1,22 @@
 import { isStandardSchema, parseWithStandardSchema } from './schema-converter'
 import type {
-  DoneStreamChunk,
   ModelMessage,
+  RunFinishedEvent,
   Tool,
   ToolCall,
-  ToolResultStreamChunk,
+  ToolCallArgsEvent,
+  ToolCallEndEvent,
+  ToolCallStartEvent,
 } from '../../../types'
 
 /**
  * Manages tool call accumulation and execution for the chat() method's automatic tool execution loop.
  *
  * Responsibilities:
- * - Accumulates streaming tool call chunks (ID, name, arguments)
+ * - Accumulates streaming tool call events (ID, name, arguments)
  * - Validates tool calls (filters out incomplete ones)
  * - Executes tool `execute` functions with parsed arguments
- * - Emits `tool_result` chunks for client visibility
+ * - Emits `TOOL_CALL_END` events for client visibility
  * - Returns tool result messages for conversation history
  *
  * This class is used internally by the AI.chat() method to handle the automatic
@@ -26,14 +28,16 @@ import type {
  *
  * // During streaming, accumulate tool calls
  * for await (const chunk of stream) {
- *   if (chunk.type === "tool_call") {
- *     manager.addToolCallChunk(chunk);
+ *   if (chunk.type === 'TOOL_CALL_START') {
+ *     manager.addToolCallStartEvent(chunk);
+ *   } else if (chunk.type === 'TOOL_CALL_ARGS') {
+ *     manager.addToolCallArgsEvent(chunk);
  *   }
  * }
  *
  * // After stream completes, execute tools
  * if (manager.hasToolCalls()) {
- *   const toolResults = yield* manager.executeTools(doneChunk);
+ *   const toolResults = yield* manager.executeTools(finishEvent);
  *   messages = [...messages, ...toolResults];
  *   manager.clear();
  * }
@@ -48,43 +52,44 @@ export class ToolCallManager {
   }
 
   /**
-   * Add a tool call chunk to the accumulator
-   * Handles streaming tool calls by accumulating arguments
+   * Add a TOOL_CALL_START event to begin tracking a tool call (AG-UI)
    */
-  addToolCallChunk(chunk: {
-    toolCall: {
-      id: string
-      type: 'function'
+  addToolCallStartEvent(event: ToolCallStartEvent): void {
+    const index = event.index ?? this.toolCallsMap.size
+    this.toolCallsMap.set(index, {
+      id: event.toolCallId,
+      type: 'function',
       function: {
-        name: string
-        arguments: string
+        name: event.toolName,
+        arguments: '',
+      },
+    })
+  }
+
+  /**
+   * Add a TOOL_CALL_ARGS event to accumulate arguments (AG-UI)
+   */
+  addToolCallArgsEvent(event: ToolCallArgsEvent): void {
+    // Find the tool call by ID
+    for (const [, toolCall] of this.toolCallsMap.entries()) {
+      if (toolCall.id === event.toolCallId) {
+        toolCall.function.arguments += event.delta
+        break
       }
     }
-    index: number
-  }): void {
-    const index = chunk.index
-    const existing = this.toolCallsMap.get(index)
-
-    if (!existing) {
-      // Only create entry if we have a tool call ID and name
-      if (chunk.toolCall.id && chunk.toolCall.function.name) {
-        this.toolCallsMap.set(index, {
-          id: chunk.toolCall.id,
-          type: 'function',
-          function: {
-            name: chunk.toolCall.function.name,
-            arguments: chunk.toolCall.function.arguments || '',
-          },
-        })
-      }
-    } else {
-      // Update name if it wasn't set before
-      if (chunk.toolCall.function.name && !existing.function.name) {
-        existing.function.name = chunk.toolCall.function.name
-      }
-      // Accumulate arguments for streaming tool calls
-      if (chunk.toolCall.function.arguments) {
-        existing.function.arguments += chunk.toolCall.function.arguments
+  }
+
+  /**
+   * Complete a tool call with its final input
+   * Called when TOOL_CALL_END is received
+   */
+  completeToolCall(event: ToolCallEndEvent): void {
+    for (const [, toolCall] of this.toolCallsMap.entries()) {
+      if (toolCall.id === event.toolCallId) {
+        if (event.input !== undefined) {
+          toolCall.function.arguments = JSON.stringify(event.input)
+        }
+        break
       }
     }
   }
@@ -107,11 +112,12 @@ export class ToolCallManager {
 
   /**
    * Execute all tool calls and return tool result messages
-   * Also yields tool_result chunks for streaming
+   * Yields TOOL_CALL_END events for streaming
+   * @param finishEvent - RUN_FINISHED event from the stream
    */
   async *executeTools(
-    doneChunk: DoneStreamChunk,
-  ): AsyncGenerator<ToolResultStreamChunk, Array<ModelMessage>, void> {
+    finishEvent: RunFinishedEvent,
+  ): AsyncGenerator<ToolCallEndEvent, Array<ModelMessage>, void> {
     const toolCallsArray = this.getToolCalls()
     const toolResults: Array<ModelMessage> = []
 
@@ -182,14 +188,14 @@ export class ToolCallManager {
         toolResultContent = `Tool ${toolCall.function.name} does not have an execute function`
       }
 
-      // Emit tool_result chunk so callers can track tool execution
+      // Emit TOOL_CALL_END event
       yield {
-        type: 'tool_result',
-        id: doneChunk.id,
-        model: doneChunk.model,
-        timestamp: Date.now(),
+        type: 'TOOL_CALL_END',
         toolCallId: toolCall.id,
-        content: toolResultContent,
+        toolName: toolCall.function.name,
+        model: finishEvent.model,
+        timestamp: Date.now(),
+        result: toolResultContent,
       }
 
       // Add tool result message
diff --git a/packages/typescript/ai/src/activities/summarize/index.ts b/packages/typescript/ai/src/activities/summarize/index.ts
index 2e28d45f..ddee4280 100644
--- a/packages/typescript/ai/src/activities/summarize/index.ts
+++ b/packages/typescript/ai/src/activities/summarize/index.ts
@@ -242,21 +242,20 @@ async function* runStreamingSummarize(
   // Fall back to non-streaming and yield as a single chunk
   const result = await adapter.summarize(summarizeOptions)
 
-  // Yield content chunk with the summary
+  // Yield TEXT_MESSAGE_CONTENT event with the summary
   yield {
-    type: 'content',
-    id: result.id,
+    type: 'TEXT_MESSAGE_CONTENT',
+    messageId: result.id,
     model: result.model,
     timestamp: Date.now(),
     delta: result.summary,
     content: result.summary,
-    role: 'assistant',
   }
 
-  // Yield done chunk
+  // Yield RUN_FINISHED event
   yield {
-    type: 'done',
-    id: result.id,
+    type: 'RUN_FINISHED',
+    runId: result.id,
     model: result.model,
     timestamp: Date.now(),
     finishReason: 'stop',
diff --git a/packages/typescript/ai/src/index.ts b/packages/typescript/ai/src/index.ts
index d65008cd..48ae1164 100644
--- a/packages/typescript/ai/src/index.ts
+++ b/packages/typescript/ai/src/index.ts
@@ -106,7 +106,6 @@ export type {
   ProcessorResult,
   ProcessorState,
   StreamProcessorEvents,
-  StreamProcessorHandlers,
   StreamProcessorOptions,
   ToolCallState,
   ToolResultState,
diff --git a/packages/typescript/ai/src/stream-to-response.ts b/packages/typescript/ai/src/stream-to-response.ts
index 5771eed7..430848ac 100644
--- a/packages/typescript/ai/src/stream-to-response.ts
+++ b/packages/typescript/ai/src/stream-to-response.ts
@@ -3,7 +3,7 @@ import type { StreamChunk } from './types'
 /**
  * Collect all text content from a StreamChunk async iterable and return as a string.
  *
- * This function consumes the entire stream, accumulating content from 'content' type chunks,
+ * This function consumes the entire stream, accumulating content from TEXT_MESSAGE_CONTENT events,
  * and returns the final concatenated text.
  *
  * @param stream - AsyncIterable of StreamChunks from chat()
@@ -26,7 +26,7 @@ export async function streamToText(
   let accumulatedContent = ''
 
   for await (const chunk of stream) {
-    if (chunk.type === 'content' && chunk.delta) {
+    if (chunk.type === 'TEXT_MESSAGE_CONTENT' && chunk.delta) {
       accumulatedContent += chunk.delta
     }
   }
@@ -77,11 +77,12 @@ export function toServerSentEventsStream(
           return
         }
 
-        // Send error chunk
+        // Send error event (AG-UI RUN_ERROR)
         controller.enqueue(
           encoder.encode(
             `data: ${JSON.stringify({
-              type: 'error',
+              type: 'RUN_ERROR',
+              timestamp: Date.now(),
               error: {
                 message: error.message || 'Unknown error occurred',
                 code: error.code,
@@ -198,11 +199,12 @@ export function toHttpStream(
           return
         }
 
-        // Send error chunk
+        // Send error event (AG-UI RUN_ERROR)
         controller.enqueue(
           encoder.encode(
             `${JSON.stringify({
-              type: 'error',
+              type: 'RUN_ERROR',
+              timestamp: Date.now(),
               error: {
                 message: error.message || 'Unknown error occurred',
                 code: error.code,
diff --git a/packages/typescript/ai/src/types.ts b/packages/typescript/ai/src/types.ts
index 7c49d995..7bd3c52d 100644
--- a/packages/typescript/ai/src/types.ts
+++ b/packages/typescript/ai/src/types.ts
@@ -649,52 +649,75 @@ export interface TextOptions<
   abortController?: AbortController
 }
 
-export type StreamChunkType =
-  | 'content'
-  | 'tool_call'
-  | 'tool_result'
-  | 'done'
-  | 'error'
-  | 'approval-requested'
-  | 'tool-input-available'
-  | 'thinking'
-
-export interface BaseStreamChunk {
-  type: StreamChunkType
-  id: string
-  model: string
-  timestamp: number
-}
+// ============================================================================
+// AG-UI Protocol Event Types
+// ============================================================================
 
-export interface ContentStreamChunk extends BaseStreamChunk {
-  type: 'content'
-  delta: string // The incremental content token
-  content: string // Full accumulated content so far
-  role?: 'assistant'
-}
+/**
+ * AG-UI Protocol event types.
+ * Based on the AG-UI specification for agent-user interaction.
+ * @see https://docs.ag-ui.com/concepts/events
+ */
+export type AGUIEventType =
+  | 'RUN_STARTED'
+  | 'RUN_FINISHED'
+  | 'RUN_ERROR'
+  | 'TEXT_MESSAGE_START'
+  | 'TEXT_MESSAGE_CONTENT'
+  | 'TEXT_MESSAGE_END'
+  | 'TOOL_CALL_START'
+  | 'TOOL_CALL_ARGS'
+  | 'TOOL_CALL_END'
+  | 'STEP_STARTED'
+  | 'STEP_FINISHED'
+  | 'STATE_SNAPSHOT'
+  | 'STATE_DELTA'
+  | 'CUSTOM'
 
-export interface ToolCallStreamChunk extends BaseStreamChunk {
-  type: 'tool_call'
-  toolCall: {
-    id: string
-    type: 'function'
-    function: {
-      name: string
-      arguments: string // Incremental JSON arguments
-    }
-  }
-  index: number
+/**
+ * Stream chunk/event types (AG-UI protocol).
+ */
+export type StreamChunkType = AGUIEventType
+
+/**
+ * Base structure for AG-UI events.
+ * Extends AG-UI spec with TanStack AI additions (model field).
+ */
+export interface BaseAGUIEvent {
+  type: AGUIEventType
+  timestamp: number
+  /** Model identifier for multi-model support */
+  model?: string
+  /** Original provider event for debugging/advanced use cases */
+  rawEvent?: unknown
 }
 
-export interface ToolResultStreamChunk extends BaseStreamChunk {
-  type: 'tool_result'
-  toolCallId: string
-  content: string
+// ============================================================================
+// AG-UI Event Interfaces
+// ============================================================================
+
+/**
+ * Emitted when a run starts.
+ * This is the first event in any streaming response.
+ */
+export interface RunStartedEvent extends BaseAGUIEvent {
+  type: 'RUN_STARTED'
+  /** Unique identifier for this run */
+  runId: string
+  /** Optional thread/conversation ID */
+  threadId?: string
 }
 
-export interface DoneStreamChunk extends BaseStreamChunk {
-  type: 'done'
+/**
+ * Emitted when a run completes successfully.
+ */
+export interface RunFinishedEvent extends BaseAGUIEvent {
+  type: 'RUN_FINISHED'
+  /** Run identifier */
+  runId: string
+  /** Why the generation stopped */
   finishReason: 'stop' | 'length' | 'content_filter' | 'tool_calls' | null
+  /** Token usage statistics */
   usage?: {
     promptTokens: number
     completionTokens: number
@@ -702,50 +725,171 @@ export interface DoneStreamChunk extends BaseStreamChunk {
   }
 }
 
-export interface ErrorStreamChunk extends BaseStreamChunk {
-  type: 'error'
+/**
+ * Emitted when an error occurs during a run.
+ */
+export interface RunErrorEvent extends BaseAGUIEvent {
+  type: 'RUN_ERROR'
+  /** Run identifier (if available) */
+  runId?: string
+  /** Error details */
   error: {
     message: string
     code?: string
   }
 }
 
-export interface ApprovalRequestedStreamChunk extends BaseStreamChunk {
-  type: 'approval-requested'
+/**
+ * Emitted when a text message starts.
+ */
+export interface TextMessageStartEvent extends BaseAGUIEvent {
+  type: 'TEXT_MESSAGE_START'
+  /** Unique identifier for this message */
+  messageId: string
+  /** Role is always assistant for generated messages */
+  role: 'assistant'
+}
+
+/**
+ * Emitted when text content is generated (streaming tokens).
+ */
+export interface TextMessageContentEvent extends BaseAGUIEvent {
+  type: 'TEXT_MESSAGE_CONTENT'
+  /** Message identifier */
+  messageId: string
+  /** The incremental content token */
+  delta: string
+  /** Full accumulated content so far */
+  content?: string
+}
+
+/**
+ * Emitted when a text message completes.
+ */
+export interface TextMessageEndEvent extends BaseAGUIEvent {
+  type: 'TEXT_MESSAGE_END'
+  /** Message identifier */
+  messageId: string
+}
+
+/**
+ * Emitted when a tool call starts.
+ */
+export interface ToolCallStartEvent extends BaseAGUIEvent {
+  type: 'TOOL_CALL_START'
+  /** Unique identifier for this tool call */
   toolCallId: string
+  /** Name of the tool being called */
   toolName: string
-  input: any
-  approval: {
-    id: string
-    needsApproval: true
-  }
+  /** Index for parallel tool calls */
+  index?: number
+}
+
+/**
+ * Emitted when tool call arguments are streaming.
+ */
+export interface ToolCallArgsEvent extends BaseAGUIEvent {
+  type: 'TOOL_CALL_ARGS'
+  /** Tool call identifier */
+  toolCallId: string
+  /** Incremental JSON arguments delta */
+  delta: string
+  /** Full accumulated arguments so far */
+  args?: string
 }
 
-export interface ToolInputAvailableStreamChunk extends BaseStreamChunk {
-  type: 'tool-input-available'
+/**
+ * Emitted when a tool call completes.
+ */
+export interface ToolCallEndEvent extends BaseAGUIEvent {
+  type: 'TOOL_CALL_END'
+  /** Tool call identifier */
   toolCallId: string
+  /** Name of the tool */
   toolName: string
-  input: any
+  /** Final parsed input arguments */
+  input?: unknown
+  /** Tool execution result (if executed) */
+  result?: string
 }
 
-export interface ThinkingStreamChunk extends BaseStreamChunk {
-  type: 'thinking'
-  delta?: string // The incremental thinking token
-  content: string // Full accumulated thinking content so far
+/**
+ * Emitted when a thinking/reasoning step starts.
+ */
+export interface StepStartedEvent extends BaseAGUIEvent {
+  type: 'STEP_STARTED'
+  /** Unique identifier for this step */
+  stepId: string
+  /** Type of step (e.g., 'thinking', 'planning') */
+  stepType?: string
+}
+
+/**
+ * Emitted when a thinking/reasoning step finishes.
+ */
+export interface StepFinishedEvent extends BaseAGUIEvent {
+  type: 'STEP_FINISHED'
+  /** Step identifier */
+  stepId: string
+  /** Incremental thinking content */
+  delta?: string
+  /** Full accumulated thinking content */
+  content?: string
+}
+
+/**
+ * Emitted to provide a full state snapshot.
+ */
+export interface StateSnapshotEvent extends BaseAGUIEvent {
+  type: 'STATE_SNAPSHOT'
+  /** The complete state object */
+  state: Record<string, unknown>
+}
+
+/**
+ * Emitted to provide an incremental state update.
+ */
+export interface StateDeltaEvent extends BaseAGUIEvent {
+  type: 'STATE_DELTA'
+  /** The state changes to apply */
+  delta: Record<string, unknown>
 }
 
 /**
- * Chunk returned by the sdk during streaming chat completions.
+ * Custom event for extensibility.
+ */
+export interface CustomEvent extends BaseAGUIEvent {
+  type: 'CUSTOM'
+  /** Custom event name */
+  name: string
+  /** Custom event data */
+  data?: unknown
+}
+
+/**
+ * Union of all AG-UI events.
+ */
+export type AGUIEvent =
+  | RunStartedEvent
+  | RunFinishedEvent
+  | RunErrorEvent
+  | TextMessageStartEvent
+  | TextMessageContentEvent
+  | TextMessageEndEvent
+  | ToolCallStartEvent
+  | ToolCallArgsEvent
+  | ToolCallEndEvent
+  | StepStartedEvent
+  | StepFinishedEvent
+  | StateSnapshotEvent
+  | StateDeltaEvent
+  | CustomEvent
+
+/**
+ * Chunk returned by the SDK during streaming chat completions.
+ * Uses the AG-UI protocol event format.
  */
-export type StreamChunk =
-  | ContentStreamChunk
-  | ToolCallStreamChunk
-  | ToolResultStreamChunk
-  | DoneStreamChunk
-  | ErrorStreamChunk
-  | ApprovalRequestedStreamChunk
-  | ToolInputAvailableStreamChunk
-  | ThinkingStreamChunk
+export type StreamChunk = AGUIEvent
 
 // Simple streaming format for basic text completions
 // Converted to StreamChunk format by convertTextCompletionStream()
diff --git a/packages/typescript/ai/tests/ai-abort.test.ts b/packages/typescript/ai/tests/ai-abort.test.ts
deleted file mode 100644
index b4f771f2..00000000
--- a/packages/typescript/ai/tests/ai-abort.test.ts
+++ /dev/null
@@ -1,231 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { z } from 'zod'
-import { chat } from '../src/activities/chat'
-import type {
-  TextOptions,
-  StreamChunk,
-  DefaultMessageMetadataByModality,
-} from '../src/types'
-import { BaseTextAdapter } from '../src/activities/chat/adapter'
-
-// Mock adapter that tracks abort signal usage
-class MockAdapter extends BaseTextAdapter<
-  'test-model',
-  Record<string, any>,
-  readonly ['text'],
-  DefaultMessageMetadataByModality
-> {
-  public receivedAbortSignals: (AbortSignal | undefined)[] = []
-  public chatStreamCallCount = 0
-
-  readonly name = 'mock'
-
-  constructor() {
-    super({}, 'test-model')
-  }
-
-  private getAbortSignal(options: TextOptions): AbortSignal | undefined {
-    const signal = (options.request as RequestInit | undefined)?.signal
-    return signal ?? undefined
-  }
-
-  async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-    this.chatStreamCallCount++
-    const abortSignal = this.getAbortSignal(options)
-    this.receivedAbortSignals.push(abortSignal)
-
-    // Yield some chunks
-    yield {
-      type: 'content',
-      id: 'test-id',
-      model: 'test-model',
-      timestamp: Date.now(),
-      delta: 'Hello',
-      content: 'Hello',
-      role: 'assistant',
-    }
-
-    // Check abort signal during streaming
-    if (abortSignal?.aborted) {
-      return
-    }
-
-    yield {
-      type: 'content',
-      id: 'test-id',
-      model: 'test-model',
-      timestamp: Date.now(),
-      delta: ' World',
-      content: 'Hello World',
-      role: 'assistant',
-    }
-
-    yield {
-      type: 'done',
-      id: 'test-id',
-      model: 'test-model',
-      timestamp: Date.now(),
-      finishReason: 'stop',
-    }
-  }
-
-  async structuredOutput(_options: any): Promise<any> {
-    return { data: {}, rawText: '{}' }
-  }
-}
-
-describe('chat() - Abort Signal Handling', () => {
-  it('should propagate abortSignal to adapter.chatStream()', async () => {
-    const mockAdapter = new MockAdapter()
-
-    const abortController = new AbortController()
-    const abortSignal = abortController.signal
-
-    const stream = chat({
-      adapter: mockAdapter,
-      messages: [{ role: 'user', content: 'Hello' }],
-      abortController,
-    })
-
-    const chunks: StreamChunk[] = []
-    for await (const chunk of stream) {
-      chunks.push(chunk)
-    }
-
-    expect(mockAdapter.chatStreamCallCount).toBe(1)
-    expect(mockAdapter.receivedAbortSignals[0]).toBe(abortSignal)
-  })
-
-  it('should stop streaming when abortSignal is aborted', async () => {
-    const mockAdapter = new MockAdapter()
-
-    const abortController = new AbortController()
-
-    const stream = chat({
-      adapter: mockAdapter,
-      messages: [{ role: 'user', content: 'Hello' }],
-      abortController,
-    })
-
-    const chunks: StreamChunk[] = []
-    let chunkCount = 0
-
-    for await (const chunk of stream) {
-      chunks.push(chunk)
-      chunkCount++
-
-      // Abort after first chunk
-      if (chunkCount === 1) {
-        abortController.abort()
-      }
-    }
-
-    // Should have received at least one chunk before abort
-    expect(chunks.length).toBeGreaterThan(0)
-  })
-
-  it('should check abortSignal before each iteration', async () => {
-    const mockAdapter = new MockAdapter()
-
-    const abortController = new AbortController()
-
-    // Abort before starting
-    abortController.abort()
-
-    const stream = chat({
-      adapter: mockAdapter,
-      messages: [{ role: 'user', content: 'Hello' }],
-      abortController,
-    })
-
-    const chunks: StreamChunk[] = []
-    for await (const chunk of stream) {
-      chunks.push(chunk)
-    }
-
-    // Should not yield any chunks if aborted before start
-    expect(chunks.length).toBe(0)
-    expect(mockAdapter.chatStreamCallCount).toBe(0)
-  })
-
-  it('should check abortSignal before tool execution', async () => {
-    const abortController = new AbortController()
-
-    // Create adapter that yields tool_calls
-    class ToolCallAdapter extends MockAdapter {
-      async *chatStream(_options: TextOptions): AsyncIterable<StreamChunk> {
-        yield {
-          type: 'tool_call',
-          id: 'test-id',
-          model: 'test-model',
-          timestamp: Date.now(),
-          toolCall: {
-            id: 'call-1',
-            type: 'function',
-            function: {
-              name: 'test_tool',
-              arguments: '{}',
-            },
-          },
-          index: 0,
-        }
-        yield {
-          type: 'done',
-          id: 'test-id',
-          model: 'test-model',
-          timestamp: Date.now(),
-          finishReason: 'tool_calls',
-        }
-      }
-    }
-
-    const toolAdapter = new ToolCallAdapter()
-
-    const stream = chat({
-      adapter: toolAdapter,
-      messages: [{ role: 'user', content: 'Hello' }],
-      tools: [
-        {
-          name: 'test_tool',
-          description: 'Test tool',
-          inputSchema: z.object({}),
-        },
-      ],
-      abortController,
-    })
-
-    const chunks: StreamChunk[] = []
-    let chunkCount = 0
-
-    for await (const chunk of stream) {
-      chunks.push(chunk)
-      chunkCount++
-
-      // Abort after receiving tool_call chunk
-      if (chunk.type === 'tool_call') {
-        abortController.abort()
-      }
-    }
-
-    // Should have received tool_call chunk but stopped before tool execution
-    expect(chunks.length).toBeGreaterThan(0)
-  })
-
-  it('should handle undefined abortSignal gracefully', async () => {
-    const mockAdapter = new MockAdapter()
-
-    const stream = chat({
-      adapter: mockAdapter,
-      messages: [{ role: 'user', content: 'Hello' }],
-    })
-
-    const chunks: StreamChunk[] = []
-    for await (const chunk of stream) {
-      chunks.push(chunk)
-    }
-
-    expect(mockAdapter.chatStreamCallCount).toBe(1)
-    expect(mockAdapter.receivedAbortSignals[0]).toBeUndefined()
-    expect(chunks.length).toBeGreaterThan(0)
-  })
-})
diff --git a/packages/typescript/ai/tests/ai-text.test.ts b/packages/typescript/ai/tests/ai-text.test.ts
deleted file mode 100644
index 8ff65fe7..00000000
--- a/packages/typescript/ai/tests/ai-text.test.ts
+++ /dev/null
@@ -1,2947 +0,0 @@
-/* eslint-disable @typescript-eslint/require-await */
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { z } from 'zod'
-import { chat } from '../src/activities/chat'
-import { BaseTextAdapter } from '../src/activities/chat/adapter'
-import { aiEventClient } from '../src/event-client.js'
-import { maxIterations } from '../src/activities/chat/agent-loop-strategies'
-import type {
-  DefaultMessageMetadataByModality,
-  ModelMessage,
-  StreamChunk,
-  TextOptions,
-  Tool,
-} from '../src/types'
-
-// Mock event client to track events
-const eventListeners = new Map<string, Set<(...args: Array<any>) => void>>()
-const capturedEvents: Array<{ type: string; data: any }> = []
-
-beforeEach(() => {
-  eventListeners.clear()
-  capturedEvents.length = 0
-
-  // Mock event client emit
-  vi.spyOn(aiEventClient, 'emit').mockImplementation((event, data) => {
-    capturedEvents.push({ type: event as string, data })
-    const listeners = eventListeners.get(event as string)
-    if (listeners) {
-      listeners.forEach((listener) => listener(data))
-    }
-    return true
-  })
-})
-
-afterEach(() => {
-  vi.restoreAllMocks()
-})
-
-// Mock adapter base class with consistent tracking helper
-class MockAdapter extends BaseTextAdapter<
-  'test-model',
-  Record<string, any>,
-  readonly ['text'],
-  DefaultMessageMetadataByModality
-> {
-  public chatStreamCallCount = 0
-  public chatStreamCalls: Array<{
-    model: string
-    messages: Array<ModelMessage>
-    tools?: Array<Tool>
-    request?: TextOptions['request']
-    systemPrompts?: Array<string>
-    modelOptions?: any
-  }> = []
-
-  readonly name = 'mock'
-
-  constructor() {
-    super({}, 'test-model')
-  }
-
-  // Helper method for consistent tracking when subclasses override chatStream
-  protected trackStreamCall(options: TextOptions): void {
-    this.chatStreamCallCount++
-    this.chatStreamCalls.push({
-      model: options.model,
-      messages: options.messages,
-      tools: options.tools,
-      request: options.request,
-      systemPrompts: options.systemPrompts,
-      modelOptions: options.modelOptions,
-    })
-  }
-
-  // Default implementation - will be overridden in tests
-  async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-    this.trackStreamCall(options)
-    yield {
-      type: 'content',
-      model: 'test-model',
-      id: 'test-id-2',
-      timestamp: Date.now(),
-      delta: 'Hello',
-      content: 'Hello',
-      role: 'assistant',
-    }
-    yield {
-      type: 'done',
-      model: 'test-model',
-      id: 'test-id-2',
-      timestamp: Date.now(),
-      finishReason: 'stop',
-    }
-  }
-
-  async structuredOutput(_options: any): Promise<any> {
-    return { data: {}, rawText: '{}' }
-  }
-}
-
-// Helper to collect all chunks from a stream
-async function collectChunks<T>(stream: AsyncIterable<T>): Promise<Array<T>> {
-  const chunks: Array<T> = []
-  for await (const chunk of stream) {
-    chunks.push(chunk)
-  }
-  return chunks
-}
-
-describe('chat() - Comprehensive Logic Path Coverage', () => {
-  describe('Initialization & Setup', () => {
-    it('should generate unique request and stream IDs', async () => {
-      const adapter = new MockAdapter()
-
-      const stream1 = chat({
-        adapter,
-        messages: [{ role: 'user', content: 'Hello' }],
-      })
-
-      const stream2 = chat({
-        adapter,
-        messages: [{ role: 'user', content: 'Hi' }],
-      })
-
-      const [chunks1, chunks2] = await Promise.all([
-        collectChunks(stream1),
-        collectChunks(stream2),
-      ])
-
-      const event1 = capturedEvents.find(
-        (e) => e.type === 'text:request:started',
-      )
-      const event2 = capturedEvents
-        .slice()
-        .reverse()
-        .find((e) => e.type === 'text:request:started')
-
-      expect(event1).toBeDefined()
-      expect(event2).toBeDefined()
-      expect(event1?.data.requestId).not.toBe(event2?.data.requestId)
-      expect(chunks1.length).toBeGreaterThan(0)
-      expect(chunks2.length).toBeGreaterThan(0)
-    })
-
-    it('should emit text:request:started event with correct data', async () => {
-      const adapter = new MockAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [
-            { role: 'user', content: 'Hello' },
-            { role: 'user', content: 'Hi' },
-          ],
-          tools: [
-            {
-              name: 'test',
-              description: 'test',
-              inputSchema: z.object({}),
-            },
-          ],
-        }),
-      )
-
-      const event = capturedEvents.find(
-        (e) => e.type === 'text:request:started',
-      )
-      expect(event).toBeDefined()
-      expect(event?.data.model).toBe('test-model')
-      expect(event?.data.messageCount).toBe(2)
-      expect(event?.data.hasTools).toBe(true)
-      expect(event?.data.streaming).toBe(true)
-    })
-
-    it('should emit text:request:started event with correct data', async () => {
-      const adapter = new MockAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Hello' }],
-        }),
-      )
-
-      const event = capturedEvents.find(
-        (e) => e.type === 'text:request:started',
-      )
-      expect(event).toBeDefined()
-      expect(event?.data.model).toBe('test-model')
-      expect(event?.data.provider).toBe('mock')
-    })
-
-    it('should forward system prompts correctly to the adapter', async () => {
-      const adapter = new MockAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Hello' }],
-          systemPrompts: ['You are concise'],
-        }),
-      )
-
-      const call = adapter.chatStreamCalls[0]
-
-      expect(call?.messages[0]?.role).not.toBe('system')
-      expect(call?.messages[0]?.content).not.toBe('You are concise')
-      expect(call?.messages[0]?.role).toBe('user')
-      expect(call?.messages[0]?.content).toBe('Hello')
-      expect(call?.systemPrompts).toBeDefined()
-      expect(call?.systemPrompts?.[0]).toBe('You are concise')
-      expect(call?.messages.length).toBe(1)
-    })
-
-    it('should prepend system prompts when provided', async () => {
-      const adapter = new MockAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Hello' }],
-          systemPrompts: ['You are helpful', 'You are concise'],
-        }),
-      )
-
-      const call = adapter.chatStreamCalls[0]
-      expect(call?.messages).toHaveLength(1)
-      expect(call?.messages[0]?.role).not.toBe('system')
-      expect(call?.systemPrompts).toBeDefined()
-      expect(call?.systemPrompts).toEqual([
-        'You are helpful',
-        'You are concise',
-      ])
-    })
-
-    it('should pass modelOptions to adapter', async () => {
-      const adapter = new MockAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Hello' }],
-          modelOptions: { customOption: 'value' },
-        }),
-      )
-
-      expect(adapter.chatStreamCalls[0]?.modelOptions).toEqual({
-        customOption: 'value',
-      })
-    })
-  })
-
-  describe('Content Streaming Paths', () => {
-    it('should stream simple content without tools', async () => {
-      const adapter = new MockAdapter()
-
-      const stream = chat({
-        adapter,
-        messages: [{ role: 'user', content: 'Hello' }],
-      })
-
-      const chunks = await collectChunks(stream)
-
-      expect(adapter.chatStreamCallCount).toBe(1)
-      expect(chunks).toHaveLength(2)
-      expect(chunks[0]?.type).toBe('content')
-      expect(chunks[1]?.type).toBe('done')
-
-      // Check events
-      expect(
-        capturedEvents.some((e) => e.type === 'text:request:started'),
-      ).toBe(true)
-      expect(capturedEvents.some((e) => e.type === 'text:chunk:content')).toBe(
-        true,
-      )
-      expect(capturedEvents.some((e) => e.type === 'text:chunk:done')).toBe(
-        true,
-      )
-    })
-
-    it('should accumulate content across multiple chunks', async () => {
-      class ContentAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'test-id-2',
-            timestamp: Date.now(),
-            delta: 'Hello',
-            content: 'Hello',
-            role: 'assistant',
-          }
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'test-id-2',
-            timestamp: Date.now(),
-            delta: ' World',
-            content: 'Hello World',
-            role: 'assistant',
-          }
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'test-id-2',
-            timestamp: Date.now(),
-            delta: '!',
-            content: 'Hello World!',
-            role: 'assistant',
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id-2',
-            timestamp: Date.now(),
-            finishReason: 'stop',
-          }
-        }
-      }
-
-      const adapter = new ContentAdapter()
-
-      const stream = chat({
-        adapter,
-        messages: [{ role: 'user', content: 'Say hello' }],
-      })
-
-      const chunks = await collectChunks(stream)
-      const contentChunks = chunks.filter((c) => c.type === 'content')
-
-      expect(contentChunks).toHaveLength(3)
-      expect((contentChunks[0] as any).content).toBe('Hello')
-      expect((contentChunks[1] as any).content).toBe('Hello World')
-      expect((contentChunks[2] as any).content).toBe('Hello World!')
-
-      // Check content events
-      const contentEvents = capturedEvents.filter(
-        (e) => e.type === 'text:chunk:content',
-      )
-      expect(contentEvents).toHaveLength(3)
-    })
-
-    it('should handle empty content chunks', async () => {
-      class EmptyContentAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'test-id-2',
-            timestamp: Date.now(),
-            delta: '',
-            content: '',
-            role: 'assistant',
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id-2',
-            timestamp: Date.now(),
-            finishReason: 'stop',
-          }
-        }
-      }
-
-      const adapter = new EmptyContentAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-        }),
-      )
-
-      expect(chunks[0]?.type).toBe('content')
-      expect((chunks[0] as any).content).toBe('')
-    })
-  })
-
-  describe('Tool Call Paths', () => {
-    it('should handle single tool call and execute it', async () => {
-      const tool: Tool = {
-        name: 'get_weather',
-        description: 'Get weather',
-        inputSchema: z.object({
-          location: z.string().optional(),
-        }),
-        execute: vi.fn(async (args: any) =>
-          JSON.stringify({ temp: 72, location: args.location }),
-        ),
-      }
-
-      class ToolAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-
-          if (this.iteration === 0) {
-            this.iteration++
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: {
-                  name: 'get_weather',
-                  arguments: '{"location":"Paris"}',
-                },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Done',
-              content: 'Done',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new ToolAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Weather?' }],
-          tools: [tool],
-        }),
-      )
-
-      expect(tool.execute).toHaveBeenCalledWith({ location: 'Paris' })
-      expect(adapter.chatStreamCallCount).toBeGreaterThanOrEqual(2)
-
-      const toolResultChunks = chunks.filter((c) => c.type === 'tool_result')
-      expect(toolResultChunks).toHaveLength(1)
-
-      // Check events
-      expect(
-        capturedEvents.some((e) => e.type === 'text:chunk:tool-call'),
-      ).toBe(true)
-      expect(
-        capturedEvents.some((e) => e.type === 'tools:call:completed'),
-      ).toBe(true)
-    })
-
-    it('should handle streaming tool call arguments (incremental JSON)', async () => {
-      const tool: Tool = {
-        name: 'calculate',
-        description: 'Calculate',
-        inputSchema: z.object({
-          a: z.number(),
-          b: z.number(),
-        }),
-        execute: vi.fn(async (args: any) =>
-          JSON.stringify({ result: args.a + args.b }),
-        ),
-      }
-
-      class StreamingToolAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-
-          if (this.iteration === 0) {
-            this.iteration++
-            // Simulate streaming tool arguments
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: {
-                  name: 'calculate',
-                  arguments: '{"a":10,',
-                },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: {
-                  name: 'calculate',
-                  arguments: '"b":20}',
-                },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Result',
-              content: 'Result',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new StreamingToolAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Calculate' }],
-          tools: [tool],
-        }),
-      )
-
-      // Tool should be executed with complete arguments
-      expect(tool.execute).toHaveBeenCalledWith({ a: 10, b: 20 })
-      const toolResultChunks = chunks.filter((c) => c.type === 'tool_result')
-      expect(toolResultChunks.length).toBeGreaterThan(0)
-    })
-
-    it('should handle multiple tool calls in same iteration', async () => {
-      const tool1: Tool = {
-        name: 'tool1',
-        description: 'Tool 1',
-        inputSchema: z.object({}),
-        execute: vi.fn(async () => JSON.stringify({ result: 1 })),
-      }
-
-      const tool2: Tool = {
-        name: 'tool2',
-        description: 'Tool 2',
-        inputSchema: z.object({}),
-        execute: vi.fn(async () => JSON.stringify({ result: 2 })),
-      }
-
-      class MultipleToolsAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-
-          if (this.iteration === 0) {
-            this.iteration++
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: { name: 'tool1', arguments: '{}' },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-2',
-                type: 'function',
-                function: { name: 'tool2', arguments: '{}' },
-              },
-              index: 1,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Done',
-              content: 'Done',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new MultipleToolsAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Use both tools' }],
-          tools: [tool1, tool2],
-        }),
-      )
-
-      expect(tool1.execute).toHaveBeenCalled()
-      expect(tool2.execute).toHaveBeenCalled()
-
-      const toolResultChunks = chunks.filter((c) => c.type === 'tool_result')
-      expect(toolResultChunks).toHaveLength(2)
-
-      // Check tool completion events
-      const toolCompletionEvents = capturedEvents.filter(
-        (e) => e.type === 'tools:call:completed',
-      )
-      expect(toolCompletionEvents.length).toBeGreaterThan(0)
-    })
-
-    it('should handle tool calls with accumulated content', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(async () => JSON.stringify({ result: 'ok' })),
-      }
-
-      class ContentWithToolsAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-
-          if (this.iteration === 0) {
-            this.iteration++
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Let me',
-              content: 'Let me',
-              role: 'assistant',
-            }
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: { name: 'test_tool', arguments: '{}' },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            // Second iteration should have assistant message with content and tool calls
-            const messages = options.messages
-            const assistantMsg = messages.find(
-              (m) => m.role === 'assistant' && m.toolCalls,
-            )
-            expect(assistantMsg).toBeDefined()
-            expect(assistantMsg?.content).toBe('Let me')
-
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Done',
-              content: 'Done',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new ContentWithToolsAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-          tools: [tool],
-        }),
-      )
-
-      expect(adapter.chatStreamCallCount).toBe(2)
-    })
-
-    it('should handle tool calls without accumulated content', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(async () => JSON.stringify({ result: 'ok' })),
-      }
-
-      class NoContentToolsAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-
-          if (this.iteration === 0) {
-            this.iteration++
-            // Only tool call, no content
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: { name: 'test_tool', arguments: '{}' },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            // Second iteration should have assistant message with null content
-            const messages = options.messages
-            const assistantMsg = messages.find(
-              (m) => m.role === 'assistant' && m.toolCalls,
-            )
-            expect(assistantMsg?.content).toBeNull()
-
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Done',
-              content: 'Done',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new NoContentToolsAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-          tools: [tool],
-        }),
-      )
-
-      expect(adapter.chatStreamCallCount).toBe(2)
-    })
-
-    it('should handle incomplete tool calls (empty name)', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-
-        description: 'Test',
-
-        inputSchema: z.object({}),
-        execute: vi.fn(),
-      }
-
-      class IncompleteToolAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          // Incomplete tool call (empty name)
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: 'test-id-2',
-            timestamp: Date.now(),
-            toolCall: {
-              id: 'call-1',
-              type: 'function',
-              function: {
-                name: '',
-                arguments: '{}',
-              },
-            },
-            index: 0,
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id-2',
-            timestamp: Date.now(),
-            finishReason: 'tool_calls',
-          }
-        }
-      }
-
-      const adapter = new IncompleteToolAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-          tools: [tool],
-        }),
-      )
-
-      // Should not execute tool (incomplete)
-      expect(tool.execute).not.toHaveBeenCalled()
-
-      // Should exit loop since no valid tool calls
-      expect(adapter.chatStreamCallCount).toBe(1)
-    })
-  })
-
-  describe('Tool Execution Result Paths', () => {
-    it('should emit tool_result chunks after execution', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(async () => JSON.stringify({ result: 'success' })),
-      }
-
-      class ToolResultAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          if (this.iteration === 0) {
-            this.iteration++
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: { name: 'test_tool', arguments: '{}' },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Done',
-              content: 'Done',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new ToolResultAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-          tools: [tool],
-        }),
-      )
-
-      const toolResultChunks = chunks.filter((c) => c.type === 'tool_result')
-      expect(toolResultChunks).toHaveLength(1)
-
-      const resultChunk = toolResultChunks[0] as any
-      const result = JSON.parse(resultChunk.content)
-      expect(result.result).toBe('success')
-
-      // Check tools:call:completed event
-      const completedEvents = capturedEvents.filter(
-        (e) => e.type === 'tools:call:completed',
-      )
-      expect(completedEvents.length).toBeGreaterThan(0)
-    })
-
-    it('should add tool result messages to conversation', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(async () => JSON.stringify({ result: 'ok' })),
-      }
-
-      class MessageHistoryAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-
-          if (this.iteration === 0) {
-            this.iteration++
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: { name: 'test_tool', arguments: '{}' },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            // Second iteration should have tool result message
-            const messages = options.messages
-            const toolMessages = messages.filter((m) => m.role === 'tool')
-            expect(toolMessages.length).toBeGreaterThan(0)
-            expect(toolMessages[0]?.toolCallId).toBe('call-1')
-
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Done',
-              content: 'Done',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new MessageHistoryAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-          tools: [tool],
-        }),
-      )
-    })
-
-    it('should handle tool execution errors gracefully', async () => {
-      const tool: Tool = {
-        name: 'error_tool',
-        description: 'Error',
-        inputSchema: z.object({}),
-        execute: vi.fn(async () => {
-          throw new Error('Tool execution failed')
-        }),
-      }
-
-      class ErrorToolAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          if (this.iteration === 0) {
-            this.iteration++
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: { name: 'error_tool', arguments: '{}' },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Error occurred',
-              content: 'Error occurred',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new ErrorToolAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Call error tool' }],
-          tools: [tool],
-        }),
-      )
-
-      const toolResultChunks = chunks.filter((c) => c.type === 'tool_result')
-      expect(toolResultChunks).toHaveLength(1)
-
-      const resultChunk = toolResultChunks[0] as any
-      const result = JSON.parse(resultChunk.content)
-      expect(result.error).toBe('Tool execution failed')
-    })
-
-    it('should handle unknown tool calls', async () => {
-      class UnknownToolAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: 'test-id-1',
-            timestamp: Date.now(),
-            toolCall: {
-              id: 'call-1',
-              type: 'function',
-              function: { name: 'unknown_tool', arguments: '{}' },
-            },
-            index: 0,
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id-1',
-            timestamp: Date.now(),
-            finishReason: 'tool_calls',
-          }
-        }
-      }
-
-      const adapter = new UnknownToolAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-          tools: [
-            {
-              name: 'known_tool',
-
-              description: 'Known',
-
-              inputSchema: z.object({}),
-            },
-          ],
-        }),
-      )
-
-      // Should still produce a tool_result with error
-      const toolResultChunks = chunks.filter((c) => c.type === 'tool_result')
-      expect(toolResultChunks.length).toBeGreaterThan(0)
-
-      const resultChunk = toolResultChunks[0] as any
-      const result = JSON.parse(resultChunk.content)
-      expect(result.error).toContain('Unknown tool')
-    })
-  })
-
-  describe('Approval & Client Tool Paths', () => {
-    it('should handle approval-required tools', async () => {
-      const tool: Tool = {
-        name: 'delete_file',
-
-        description: 'Delete',
-
-        inputSchema: z.object({}),
-        needsApproval: true,
-        execute: vi.fn(async () => JSON.stringify({ success: true })),
-      }
-
-      class ApprovalAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: 'test-id-1',
-            timestamp: Date.now(),
-            toolCall: {
-              id: 'call-1',
-              type: 'function',
-              function: {
-                name: 'delete_file',
-                arguments: '{"path":"/tmp/test.txt"}',
-              },
-            },
-            index: 0,
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id-1',
-            timestamp: Date.now(),
-            finishReason: 'tool_calls',
-          }
-        }
-      }
-
-      const adapter = new ApprovalAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Delete file' }],
-          tools: [tool],
-        }),
-      )
-
-      const approvalChunks = chunks.filter(
-        (c) => c.type === 'approval-requested',
-      )
-      expect(approvalChunks).toHaveLength(1)
-
-      const approvalChunk = approvalChunks[0] as any
-      expect(approvalChunk.toolName).toBe('delete_file')
-      expect(approvalChunk.approval.needsApproval).toBe(true)
-
-      // Tool should NOT be executed yet
-      expect(tool.execute).not.toHaveBeenCalled()
-
-      // Should emit approval-requested event
-      expect(
-        capturedEvents.some((e) => e.type === 'tools:approval:requested'),
-      ).toBe(true)
-    })
-
-    it('should handle client-side tools (no execute)', async () => {
-      const tool: Tool = {
-        name: 'client_tool',
-
-        description: 'Client',
-
-        inputSchema: z.object({
-          input: z.string(),
-        }),
-        // No execute function
-      }
-
-      class ClientToolAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: 'test-id-1',
-            timestamp: Date.now(),
-            toolCall: {
-              id: 'call-1',
-              type: 'function',
-              function: { name: 'client_tool', arguments: '{"input":"test"}' },
-            },
-            index: 0,
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id-1',
-            timestamp: Date.now(),
-            finishReason: 'tool_calls',
-          }
-        }
-      }
-
-      const adapter = new ClientToolAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Use client tool' }],
-          tools: [tool],
-        }),
-      )
-
-      const inputChunks = chunks.filter(
-        (c) => c.type === 'tool-input-available',
-      )
-      expect(inputChunks).toHaveLength(1)
-
-      const inputChunk = inputChunks[0] as any
-      expect(inputChunk.toolName).toBe('client_tool')
-      expect(inputChunk.input).toEqual({ input: 'test' })
-
-      // Should emit tool-input-available event
-      expect(
-        capturedEvents.some((e) => e.type === 'tools:input:available'),
-      ).toBe(true)
-    })
-
-    it('should handle mixed tools (approval + client + normal)', async () => {
-      const normalTool: Tool = {
-        name: 'normal',
-        description: 'Normal',
-        inputSchema: z.object({}),
-        execute: vi.fn(async () => JSON.stringify({ result: 'ok' })),
-      }
-
-      const approvalTool: Tool = {
-        name: 'approval',
-        description: 'Approval',
-        inputSchema: z.object({}),
-        needsApproval: true,
-        execute: vi.fn(async () => JSON.stringify({ success: true })),
-      }
-
-      const clientTool: Tool = {
-        name: 'client',
-        description: 'Client',
-        inputSchema: z.object({}),
-        // No execute
-      }
-
-      class MixedToolsAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: 'test-id-1',
-            timestamp: Date.now(),
-            toolCall: {
-              id: 'call-1',
-              type: 'function',
-              function: { name: 'normal', arguments: '{}' },
-            },
-            index: 0,
-          }
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: 'test-id-1',
-            timestamp: Date.now(),
-            toolCall: {
-              id: 'call-2',
-              type: 'function',
-              function: { name: 'approval', arguments: '{}' },
-            },
-            index: 1,
-          }
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: 'test-id-1',
-            timestamp: Date.now(),
-            toolCall: {
-              id: 'call-3',
-              type: 'function',
-              function: { name: 'client', arguments: '{}' },
-            },
-            index: 2,
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id-1',
-            timestamp: Date.now(),
-            finishReason: 'tool_calls',
-          }
-        }
-      }
-
-      const adapter = new MixedToolsAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Use all tools' }],
-          tools: [normalTool, approvalTool, clientTool],
-        }),
-      )
-
-      // Normal tool should be executed
-      expect(normalTool.execute).toHaveBeenCalled()
-
-      // Approval and client tools should request intervention
-      const approvalChunks = chunks.filter(
-        (c) => c.type === 'approval-requested',
-      )
-      const inputChunks = chunks.filter(
-        (c) => c.type === 'tool-input-available',
-      )
-
-      expect(approvalChunks.length + inputChunks.length).toBeGreaterThan(0)
-
-      // Should stop after emitting approval/client chunks
-      expect(approvalTool.execute).not.toHaveBeenCalled()
-    })
-
-    it('should execute pending tool calls before streaming when approvals already exist', async () => {
-      const toolExecute = vi
-        .fn()
-        .mockResolvedValue(JSON.stringify({ success: true }))
-
-      const approvalTool: Tool = {
-        name: 'approval_tool',
-
-        description: 'Needs approval',
-
-        inputSchema: z.object({
-          path: z.string(),
-        }),
-        needsApproval: true,
-        execute: toolExecute,
-      }
-
-      class PendingToolAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-
-          const toolMessage = options.messages.find(
-            (msg) => msg.role === 'tool',
-          )
-          expect(toolMessage).toBeDefined()
-          expect(toolMessage?.toolCallId).toBe('call-1')
-          expect(toolMessage?.content).toBe(JSON.stringify({ success: true }))
-
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'done-id',
-            timestamp: Date.now(),
-            delta: 'Finished',
-            content: 'Finished',
-            role: 'assistant',
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'done-id',
-            timestamp: Date.now(),
-            finishReason: 'stop',
-          }
-        }
-      }
-
-      const adapter = new PendingToolAdapter()
-
-      const messages = [
-        { role: 'user', content: 'Delete file' },
-        {
-          role: 'assistant',
-          content: null,
-          toolCalls: [
-            {
-              id: 'call-1',
-              type: 'function',
-              function: {
-                name: 'approval_tool',
-                arguments: '{"path":"/tmp/test.txt"}',
-              },
-            },
-          ],
-          parts: [
-            {
-              type: 'tool-call',
-              id: 'call-1',
-              name: 'approval_tool',
-              arguments: '{"path":"/tmp/test.txt"}',
-              state: 'approval-responded',
-              approval: {
-                id: 'approval_call-1',
-                needsApproval: true,
-                approved: true,
-              },
-            },
-          ],
-        } as any,
-      ]
-
-      const stream = chat({
-        adapter,
-        messages,
-        tools: [approvalTool],
-      })
-
-      const chunks = await collectChunks(stream)
-      expect(chunks[0]?.type).toBe('tool_result')
-      expect(toolExecute).toHaveBeenCalledWith({ path: '/tmp/test.txt' })
-      expect(adapter.chatStreamCallCount).toBe(1)
-    })
-  })
-
-  describe('Agent Loop Strategy Paths', () => {
-    it('should respect custom agent loop strategy', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(async () => JSON.stringify({ result: 'ok' })),
-      }
-
-      class LoopAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          if (this.iteration < 3) {
-            this.iteration++
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: `test-id-${this.iteration}`,
-              timestamp: Date.now(),
-              toolCall: {
-                id: `call-${this.iteration}`,
-                type: 'function',
-                function: { name: 'test_tool', arguments: '{}' },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: `test-id-${this.iteration}`,
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: `test-id-${this.iteration}`,
-              timestamp: Date.now(),
-              delta: 'Done',
-              content: 'Done',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: `test-id-${this.iteration}`,
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new LoopAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Loop' }],
-          tools: [tool],
-          agentLoopStrategy: ({ iterationCount }) => iterationCount < 2, // Max 2 iterations
-        }),
-      )
-
-      // Should stop after max iterations
-      expect(adapter.chatStreamCallCount).toBeLessThanOrEqual(3)
-    })
-
-    it('should use default max iterations strategy (5)', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(async () => JSON.stringify({ result: 'ok' })),
-      }
-
-      class InfiniteLoopAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: `test-id-${this.iteration}`,
-            timestamp: Date.now(),
-            toolCall: {
-              id: `call-${this.iteration}`,
-              type: 'function',
-              function: { name: 'test_tool', arguments: '{}' },
-            },
-            index: 0,
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: `test-id-${this.iteration}`,
-            timestamp: Date.now(),
-            finishReason: 'tool_calls',
-          }
-          this.iteration++
-        }
-      }
-
-      const adapter = new InfiniteLoopAdapter()
-
-      // Consume stream - should stop after 5 iterations (default)
-      const chunks: Array<StreamChunk> = []
-      for await (const chunk of chat({
-        adapter,
-        messages: [{ role: 'user', content: 'Loop' }],
-        tools: [tool],
-        // No custom strategy - should use default maxIterations(5)
-      })) {
-        chunks.push(chunk)
-        // Safety break
-        if (chunks.length > 100) break
-      }
-
-      // Should stop at max iterations (5) + 1 initial = 6 calls max
-      expect(adapter.chatStreamCallCount).toBeLessThanOrEqual(6)
-    })
-
-    it("should exit loop when finishReason is not 'tool_calls'", async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(),
-      }
-
-      class StopAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            delta: 'Hello',
-            content: 'Hello',
-            role: 'assistant',
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            finishReason: 'stop', // Not tool_calls
-          }
-        }
-      }
-
-      const adapter = new StopAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Hello' }],
-          tools: [tool],
-        }),
-      )
-
-      expect(tool.execute).not.toHaveBeenCalled()
-      expect(adapter.chatStreamCallCount).toBe(1)
-    })
-
-    it('should exit loop when no tools provided', async () => {
-      class NoToolsAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            toolCall: {
-              id: 'call-1',
-              type: 'function',
-              function: { name: 'unknown_tool', arguments: '{}' },
-            },
-            index: 0,
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            finishReason: 'tool_calls',
-          }
-        }
-      }
-
-      const adapter = new NoToolsAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-          // No tools provided
-        }),
-      )
-
-      // Should exit loop since no tools to execute
-      expect(adapter.chatStreamCallCount).toBe(1)
-    })
-
-    it('should exit loop when toolCallManager has no tool calls', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(),
-      }
-
-      class NoToolCallsAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          // Tool call with empty name (invalid)
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            toolCall: {
-              id: 'call-1',
-              type: 'function',
-              function: { name: '', arguments: '{}' }, // Empty name
-            },
-            index: 0,
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            finishReason: 'tool_calls',
-          }
-        }
-      }
-
-      const adapter = new NoToolCallsAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-          tools: [tool],
-        }),
-      )
-
-      // Should exit loop since no valid tool calls
-      expect(tool.execute).not.toHaveBeenCalled()
-      expect(adapter.chatStreamCallCount).toBe(1)
-    })
-  })
-
-  describe('Abort Signal Paths', () => {
-    it('should check abort signal before starting iteration', async () => {
-      const adapter = new MockAdapter()
-
-      const abortController = new AbortController()
-      abortController.abort() // Abort before starting
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Hello' }],
-          abortController,
-        }),
-      )
-
-      // Should not yield any chunks if aborted before start
-      expect(chunks.length).toBe(0)
-      expect(adapter.chatStreamCallCount).toBe(0)
-    })
-
-    it('should check abort signal during streaming', async () => {
-      class StreamingAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            delta: 'Chunk 1',
-            content: 'Chunk 1',
-            role: 'assistant',
-          }
-          // Abort check happens in chat method between chunks
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            delta: 'Chunk 2',
-            content: 'Chunk 2',
-            role: 'assistant',
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            finishReason: 'stop',
-          }
-        }
-      }
-
-      const adapter = new StreamingAdapter()
-
-      const abortController = new AbortController()
-      const stream = chat({
-        adapter,
-        messages: [{ role: 'user', content: 'Hello' }],
-        abortController,
-      })
-
-      const chunks: Array<StreamChunk> = []
-      let count = 0
-
-      for await (const chunk of stream) {
-        chunks.push(chunk)
-        count++
-        if (count === 1) {
-          abortController.abort()
-        }
-      }
-
-      // Should have at least one chunk before abort
-      expect(chunks.length).toBeGreaterThan(0)
-    })
-
-    it('should check abort signal before tool execution', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(),
-      }
-
-      class ToolCallAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            toolCall: {
-              id: 'call-1',
-              type: 'function',
-              function: { name: 'test_tool', arguments: '{}' },
-            },
-            index: 0,
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            finishReason: 'tool_calls',
-          }
-        }
-      }
-
-      const adapter = new ToolCallAdapter()
-
-      const abortController = new AbortController()
-      const stream = chat({
-        adapter,
-        messages: [{ role: 'user', content: 'Test' }],
-        tools: [tool],
-        abortController,
-      })
-
-      const chunks: Array<StreamChunk> = []
-      for await (const chunk of stream) {
-        chunks.push(chunk)
-        if (chunk.type === 'tool_call') {
-          abortController.abort()
-        }
-      }
-
-      // Should not execute tool if aborted
-      expect(tool.execute).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('Error Handling Paths', () => {
-    it('should stop on error chunk and return early', async () => {
-      class ErrorAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            delta: 'Hello',
-            content: 'Hello',
-            role: 'assistant',
-          }
-          yield {
-            type: 'error',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            error: {
-              message: 'API error occurred',
-              code: 'API_ERROR',
-            },
-          }
-          // These should never be yielded
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            finishReason: 'stop',
-          } as any
-        }
-      }
-
-      const adapter = new ErrorAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Hello' }],
-        }),
-      )
-
-      // Should stop at error chunk
-      expect(chunks).toHaveLength(2)
-      expect(chunks[0]?.type).toBe('content')
-      expect(chunks[1]?.type).toBe('error')
-      expect((chunks[1] as any).error.message).toBe('API error occurred')
-
-      // Should emit error event
-      expect(capturedEvents.some((e) => e.type === 'text:chunk:error')).toBe(
-        true,
-      )
-    })
-  })
-
-  describe('Finish Reason Paths', () => {
-    it("should handle finish reason 'stop'", async () => {
-      class StopFinishAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            delta: 'Done',
-            content: 'Done',
-            role: 'assistant',
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            finishReason: 'stop',
-          }
-        }
-      }
-
-      const adapter = new StopFinishAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-        }),
-      )
-
-      expect((chunks[1] as any).finishReason).toBe('stop')
-      expect(adapter.chatStreamCallCount).toBe(1)
-    })
-
-    it("should handle finish reason 'length'", async () => {
-      class LengthAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            delta: 'Very long',
-            content: 'Very long',
-            role: 'assistant',
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            finishReason: 'length',
-          }
-        }
-      }
-
-      const adapter = new LengthAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-        }),
-      )
-
-      expect((chunks[1] as any).finishReason).toBe('length')
-      expect(adapter.chatStreamCallCount).toBe(1)
-    })
-
-    it('should handle finish reason null', async () => {
-      class NullFinishAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            delta: 'Test',
-            content: 'Test',
-            role: 'assistant',
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            finishReason: null,
-          }
-        }
-      }
-
-      const adapter = new NullFinishAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-        }),
-      )
-
-      expect(chunks.length).toBe(2)
-      expect((chunks[1] as any).finishReason).toBeNull()
-      expect(adapter.chatStreamCallCount).toBe(1)
-    })
-  })
-
-  describe('Event Emission', () => {
-    it('should emit all required events in correct order', async () => {
-      const adapter = new MockAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Hello' }],
-        }),
-      )
-
-      const eventTypes = capturedEvents.map((e) => e.type)
-
-      // Check event order and presence
-      expect(eventTypes.includes('text:request:started')).toBe(true)
-      expect(eventTypes.includes('text:chunk:content')).toBe(true)
-      expect(eventTypes.includes('text:chunk:done')).toBe(true)
-      expect(eventTypes.includes('text:request:completed')).toBe(true)
-
-      // request:started should come before first content chunk
-      const requestStartedIndex = eventTypes.indexOf('text:request:started')
-      const contentIndex = eventTypes.indexOf('text:chunk:content')
-      expect(requestStartedIndex).toBeLessThan(contentIndex)
-    })
-
-    it('should emit iteration events for tool calls', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(async () => JSON.stringify({ result: 'ok' })),
-      }
-
-      class ToolAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          if (this.iteration === 0) {
-            this.iteration++
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: { name: 'test_tool', arguments: '{}' },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Done',
-              content: 'Done',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new ToolAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-          tools: [tool],
-        }),
-      )
-
-      // Should emit tools:call:completed event
-      const toolCompletionEvents = capturedEvents.filter(
-        (e) => e.type === 'tools:call:completed',
-      )
-      expect(toolCompletionEvents.length).toBeGreaterThan(0)
-    })
-
-    it('should emit text:request:completed event after successful completion', async () => {
-      const adapter = new MockAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Hello' }],
-        }),
-      )
-
-      const completedEvent = capturedEvents.find(
-        (e) => e.type === 'text:request:completed',
-      )
-      expect(completedEvent).toBeDefined()
-      expect(completedEvent?.data.duration).toBeGreaterThanOrEqual(0)
-    })
-
-    it('should track total chunk count across iterations', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(async () => JSON.stringify({ result: 'ok' })),
-      }
-
-      class MultiIterationAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          if (this.iteration === 0) {
-            this.iteration++
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              delta: 'Let me',
-              content: 'Let me',
-              role: 'assistant',
-            }
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: { name: 'test_tool', arguments: '{}' },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Done',
-              content: 'Done',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new MultiIterationAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-          tools: [tool],
-        }),
-      )
-
-      const completedEvent = capturedEvents.find(
-        (e) => e.type === 'text:request:completed',
-      )
-      expect(completedEvent).toBeDefined()
-    })
-  })
-
-  describe('Edge Cases', () => {
-    it('should handle empty messages array', async () => {
-      const adapter = new MockAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [],
-        }),
-      )
-
-      expect(chunks.length).toBeGreaterThan(0)
-      expect(adapter.chatStreamCalls[0]?.messages).toHaveLength(0)
-    })
-
-    it('should handle empty tools array', async () => {
-      const adapter = new MockAdapter()
-
-      const chunks = await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Hello' }],
-          tools: [],
-        }),
-      )
-
-      expect(chunks.length).toBeGreaterThan(0)
-    })
-
-    it('should handle tool calls with missing ID', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(),
-      }
-
-      class MissingIdAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            toolCall: {
-              id: '', // Empty ID
-              type: 'function',
-              function: { name: 'test_tool', arguments: '{}' },
-            },
-            index: 0,
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            finishReason: 'tool_calls',
-          }
-        }
-      }
-
-      const adapter = new MissingIdAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Test' }],
-          tools: [tool],
-        }),
-      )
-
-      // Tool should not be executed (invalid tool call)
-      expect(tool.execute).not.toHaveBeenCalled()
-    })
-
-    it('should handle tool call with invalid JSON arguments', async () => {
-      const tool: Tool = {
-        name: 'test_tool',
-        description: 'Test',
-        inputSchema: z.object({}),
-        execute: vi.fn(),
-      }
-
-      class InvalidJsonAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'tool_call',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            toolCall: {
-              id: 'call-1',
-              type: 'function',
-              function: { name: 'test_tool', arguments: 'invalid json{' },
-            },
-            index: 0,
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            finishReason: 'tool_calls',
-          }
-        }
-      }
-
-      const adapter = new InvalidJsonAdapter()
-
-      // The executor will throw when parsing invalid JSON
-      // This will cause an unhandled error, but we can test that it throws
-      await expect(
-        collectChunks(
-          chat({
-            adapter,
-            messages: [{ role: 'user', content: 'Test' }],
-            tools: [tool],
-          }),
-        ),
-      ).rejects.toThrow() // Should throw due to JSON parse error in executor
-    })
-  })
-
-  describe('Tool Result Chunk Events from Adapter', () => {
-    it('should emit text:chunk:tool-result event when adapter sends tool_result chunk', async () => {
-      class ToolResultChunkAdapter extends MockAdapter {
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          yield {
-            type: 'content',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            delta: 'Using tool',
-            content: 'Using tool',
-            role: 'assistant',
-          }
-          // Adapter sends tool_result chunk directly (from previous execution)
-          yield {
-            type: 'tool_result',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            toolCallId: 'call-previous',
-            content: JSON.stringify({ result: 'previous result' }),
-          }
-          yield {
-            type: 'done',
-            model: 'test-model',
-            id: 'test-id',
-            timestamp: Date.now(),
-            finishReason: 'stop',
-          }
-        }
-      }
-
-      const adapter = new ToolResultChunkAdapter()
-
-      await collectChunks(
-        chat({
-          adapter,
-          messages: [{ role: 'user', content: 'Continue' }],
-        }),
-      )
-
-      // Should emit tool-result event for the tool_result chunk from adapter
-      const toolResultEvents = capturedEvents.filter(
-        (e) => e.type === 'text:chunk:tool-result',
-      )
-      expect(toolResultEvents.length).toBeGreaterThan(0)
-      expect(toolResultEvents[0]?.data.toolCallId).toBe('call-previous')
-      expect(toolResultEvents[0]?.data.result).toBe(
-        JSON.stringify({ result: 'previous result' }),
-      )
-    })
-  })
-
-  describe('Extract Approvals and Client Tool Results from Messages', () => {
-    it('should extract approval responses from messages with parts', async () => {
-      const tool: Tool = {
-        name: 'delete_file',
-
-        description: 'Delete file',
-
-        inputSchema: z.object({
-          path: z.string(),
-        }),
-        needsApproval: true,
-        execute: vi.fn(async () => JSON.stringify({ success: true })),
-      }
-
-      class ApprovalResponseAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-
-          // Check if messages have approval response in parts
-          const hasApprovalResponse = options.messages.some((msg) => {
-            if (msg.role === 'assistant' && (msg as any).parts) {
-              const parts = (msg as any).parts
-              return parts.some(
-                (p: any) =>
-                  p.type === 'tool-call' &&
-                  p.state === 'approval-responded' &&
-                  p.approval?.approved === true,
-              )
-            }
-            return false
-          })
-
-          if (hasApprovalResponse) {
-            // Messages have approval response - yield tool_calls again to trigger execution
-            // The approval will be extracted from parts and tool will be executed
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: {
-                  name: 'delete_file',
-                  arguments: '{"path":"/tmp/test.txt"}',
-                },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            // First iteration: request approval
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: {
-                  name: 'delete_file',
-                  arguments: '{"path":"/tmp/test.txt"}',
-                },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          }
-        }
-      }
-
-      const adapter = new ApprovalResponseAdapter()
-
-      // First call - should request approval
-      const stream1 = chat({
-        adapter,
-        messages: [{ role: 'user', content: 'Delete file' }],
-        tools: [tool],
-      })
-
-      const chunks1 = await collectChunks(stream1)
-      const approvalChunk = chunks1.find((c) => c.type === 'approval-requested')
-      expect(approvalChunk).toBeDefined()
-
-      // Second call - with approval response in message parts
-      // The approval ID should match the format: approval_${toolCall.id}
-      const messagesWithApproval = [
-        { role: 'user', content: 'Delete file' },
-        {
-          role: 'assistant',
-          content: null,
-          toolCalls: [
-            {
-              id: 'call-1',
-              type: 'function',
-              function: {
-                name: 'delete_file',
-                arguments: '{"path":"/tmp/test.txt"}',
-              },
-            },
-          ],
-          parts: [
-            {
-              type: 'tool-call',
-              id: 'call-1',
-              name: 'delete_file',
-              arguments: '{"path":"/tmp/test.txt"}',
-              state: 'approval-responded',
-              approval: {
-                id: 'approval_call-1', // Format: approval_${toolCall.id}
-                needsApproval: true,
-                approved: true, // User approved
-              },
-            },
-          ],
-        } as any,
-      ]
-
-      const stream2 = chat({
-        adapter,
-        messages: messagesWithApproval,
-        tools: [tool],
-      })
-
-      await collectChunks(stream2)
-
-      // Tool should have been executed because approval was provided
-      expect(tool.execute).toHaveBeenCalledWith({ path: '/tmp/test.txt' })
-    })
-
-    it('should extract client tool outputs from messages with parts', async () => {
-      const tool: Tool = {
-        name: 'client_tool',
-
-        description: 'Client tool',
-
-        inputSchema: z.object({}),
-        // No execute - client-side tool
-      }
-
-      class ClientOutputAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-
-          if (this.iteration === 0) {
-            this.iteration++
-            // First iteration: request client execution
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: {
-                  name: 'client_tool',
-                  arguments: '{"input":"test"}',
-                },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            // Second iteration: should have client tool output in parts
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Received result',
-              content: 'Received result',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new ClientOutputAdapter()
-
-      // First call - should request client execution
-      const stream1 = chat({
-        adapter,
-        messages: [{ role: 'user', content: 'Use client tool' }],
-        tools: [tool],
-      })
-
-      const chunks1 = await collectChunks(stream1)
-      const inputChunk = chunks1.find((c) => c.type === 'tool-input-available')
-      expect(inputChunk).toBeDefined()
-
-      // Second call - with client tool output in message parts
-      const messagesWithOutput = [
-        { role: 'user', content: 'Use client tool' },
-        {
-          role: 'assistant',
-          content: null,
-          toolCalls: [
-            {
-              id: 'call-1',
-              type: 'function',
-              function: {
-                name: 'client_tool',
-                arguments: '{"input":"test"}',
-              },
-            },
-          ],
-          parts: [
-            {
-              type: 'tool-call',
-              id: 'call-1',
-              name: 'client_tool',
-              arguments: '{"input":"test"}',
-              state: 'complete',
-              output: { result: 'client executed', value: 42 }, // Client tool output
-            },
-          ],
-        } as any,
-      ]
-
-      const stream2 = chat({
-        adapter,
-        messages: messagesWithOutput,
-        tools: [tool],
-      })
-
-      await collectChunks(stream2)
-
-      // Should continue to next iteration (tool result extracted from parts)
-      expect(adapter.chatStreamCallCount).toBeGreaterThan(1)
-    })
-
-    it('should handle messages with both approval and client tool parts', async () => {
-      const approvalTool: Tool = {
-        name: 'approval_tool',
-
-        description: 'Approval',
-
-        inputSchema: z.object({}),
-        needsApproval: true,
-        execute: vi.fn(async () => JSON.stringify({ success: true })),
-      }
-
-      const clientTool: Tool = {
-        name: 'client_tool',
-
-        description: 'Client',
-
-        inputSchema: z.object({}),
-        // No execute
-      }
-
-      class MixedPartsAdapter extends MockAdapter {
-        iteration = 0
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          if (this.iteration === 0) {
-            this.iteration++
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-1',
-                type: 'function',
-                function: { name: 'approval_tool', arguments: '{}' },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'call-2',
-                type: 'function',
-                function: { name: 'client_tool', arguments: '{"x":1}' },
-              },
-              index: 1,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-1',
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-            }
-          } else {
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              delta: 'Done',
-              content: 'Done',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: 'test-id-2',
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-          }
-        }
-      }
-
-      const adapter = new MixedPartsAdapter()
-
-      // Call with messages containing both approval response and client tool output in parts
-      const messagesWithBoth = [
-        { role: 'user', content: 'Use both tools' },
-        {
-          role: 'assistant',
-          content: null,
-          toolCalls: [
-            {
-              id: 'call-1',
-              type: 'function',
-              function: { name: 'approval_tool', arguments: '{}' },
-            },
-            {
-              id: 'call-2',
-              type: 'function',
-              function: { name: 'client_tool', arguments: '{"x":1}' },
-            },
-          ],
-          parts: [
-            {
-              type: 'tool-call',
-              id: 'call-1',
-              name: 'approval_tool',
-              arguments: '{}',
-              state: 'approval-responded',
-              approval: {
-                id: 'approval_call-1',
-                needsApproval: true,
-                approved: true,
-              },
-            },
-            {
-              type: 'tool-call',
-              id: 'call-2',
-              name: 'client_tool',
-              arguments: '{"x":1}',
-              state: 'complete',
-              output: { result: 'client result' },
-            },
-          ],
-        } as any,
-      ]
-
-      const stream = chat({
-        adapter,
-        messages: messagesWithBoth,
-        tools: [approvalTool, clientTool],
-      })
-
-      await collectChunks(stream)
-
-      // Approval tool should be executed (approval was provided)
-      expect(approvalTool.execute).toHaveBeenCalled()
-      // Should continue with tool results from parts
-      expect(adapter.chatStreamCallCount).toBeGreaterThan(1)
-    })
-  })
-
-  describe('Temperature Tool Test - Debugging Tool Execution', () => {
-    it('should execute tool and continue loop when receiving tool_calls finishReason with maxIterations(20)', async () => {
-      // Create a tool that returns "70" like the failing test
-      const temperatureTool: Tool = {
-        name: 'get_temperature',
-        description: 'Get the current temperature in degrees',
-        inputSchema: z.object({}),
-        execute: vi.fn(async (_args: any) => {
-          return '70'
-        }),
-      }
-
-      // Create adapter that mimics the failing test output
-      class TemperatureToolAdapter extends MockAdapter {
-        iteration = 0
-
-        async *chatStream(options: TextOptions): AsyncIterable<StreamChunk> {
-          this.trackStreamCall(options)
-          const baseId = `test-${Date.now()}-${Math.random()
-            .toString(36)
-            .substring(7)}`
-
-          if (this.iteration === 0) {
-            // First iteration: emit content chunks, tool_call, then done with tool_calls
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: baseId,
-              timestamp: Date.now(),
-              delta: 'I',
-              content: 'I',
-              role: 'assistant',
-            }
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: baseId,
-              timestamp: Date.now(),
-              delta: "'ll help you check the current temperature right away.",
-              content:
-                "I'll help you check the current temperature right away.",
-              role: 'assistant',
-            }
-            yield {
-              type: 'tool_call',
-              model: 'test-model',
-              id: baseId,
-              timestamp: Date.now(),
-              toolCall: {
-                id: 'toolu_01D28jUnxcHQ5qqewJ7X6p1K',
-                type: 'function',
-                function: {
-                  name: 'get_temperature',
-                  // Empty string like in the actual failing test - should be handled gracefully
-                  arguments: '',
-                },
-              },
-              index: 0,
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: baseId,
-              timestamp: Date.now(),
-              finishReason: 'tool_calls',
-              usage: {
-                promptTokens: 0,
-                completionTokens: 48,
-                totalTokens: 48,
-              },
-            }
-            this.iteration++
-          } else {
-            // Second iteration: should receive tool result and respond with "70"
-            // This simulates what should happen after tool execution
-            const toolResults = options.messages.filter(
-              (m) => m.role === 'tool',
-            )
-            expect(toolResults.length).toBeGreaterThan(0)
-            expect(toolResults[0]?.content).toBe('70')
-
-            yield {
-              type: 'content',
-              model: 'test-model',
-              id: `${baseId}-2`,
-              timestamp: Date.now(),
-              delta: 'The current temperature is 70 degrees.',
-              content: 'The current temperature is 70 degrees.',
-              role: 'assistant',
-            }
-            yield {
-              type: 'done',
-              model: 'test-model',
-              id: `${baseId}-2`,
-              timestamp: Date.now(),
-              finishReason: 'stop',
-            }
-            this.iteration++
-          }
-        }
-      }
-
-      const adapter = new TemperatureToolAdapter()
-
-      const stream = chat({
-        adapter,
-        messages: [{ role: 'user', content: 'what is the temperature?' }],
-        tools: [temperatureTool],
-        agentLoopStrategy: maxIterations(20),
-      })
-
-      const chunks = await collectChunks(stream)
-
-      const toolCallChunks = chunks.filter((c) => c.type === 'tool_call')
-      const toolResultChunks = chunks.filter((c) => c.type === 'tool_result')
-
-      // We should have received tool_call chunks
-      expect(toolCallChunks.length).toBeGreaterThan(0)
-
-      // The tool should have been executed
-      expect(temperatureTool.execute).toHaveBeenCalled()
-
-      // We should have tool_result chunks
-      expect(toolResultChunks.length).toBeGreaterThan(0)
-
-      // The adapter should have been called multiple times (at least 2: initial + after tool execution)
-      expect(adapter.chatStreamCallCount).toBeGreaterThanOrEqual(2)
-
-      // We should have at least one content chunk with "70" in it
-      const contentChunks = chunks.filter((c) => c.type === 'content')
-      const hasSeventy = contentChunks.some((c) =>
-        (c as any).content?.toLowerCase().includes('70'),
-      )
-      expect(hasSeventy).toBe(true)
-    })
-  })
-})
diff --git a/packages/typescript/ai/tests/generate.test.ts b/packages/typescript/ai/tests/generate.test.ts
deleted file mode 100644
index 93fa7144..00000000
--- a/packages/typescript/ai/tests/generate.test.ts
+++ /dev/null
@@ -1,229 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import {
-  BaseSummarizeAdapter,
-  BaseTextAdapter,
-  chat,
-  summarize,
-} from '../src/activities'
-import type { StructuredOutputResult } from '../src/activities'
-import type {
-  ModelMessage,
-  StreamChunk,
-  SummarizationOptions,
-  SummarizationResult,
-  TextOptions,
-} from '../src'
-
-// Mock adapters for testing
-
-const MOCK_MODELS = ['model-a', 'model-b'] as const
-type MockModel = (typeof MOCK_MODELS)[number]
-
-class MockTextAdapter<
-  TModel extends MockModel = 'model-a',
-> extends BaseTextAdapter<
-  TModel,
-  Record<string, unknown>,
-  readonly ['text', 'image', 'audio', 'video', 'document'],
-  {
-    text: unknown
-    image: unknown
-    audio: unknown
-    video: unknown
-    document: unknown
-  }
-> {
-  readonly kind = 'text' as const
-  readonly name = 'mock' as const
-
-  private mockChunks: Array<StreamChunk>
-
-  constructor(
-    mockChunks: Array<StreamChunk> = [],
-    model: TModel = 'model-a' as TModel,
-  ) {
-    super({}, model)
-    this.mockChunks = mockChunks
-  }
-
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async *chatStream(_options: TextOptions): AsyncIterable<StreamChunk> {
-    for (const chunk of this.mockChunks) {
-      yield chunk
-    }
-  }
-
-  structuredOutput(_options: any): Promise<StructuredOutputResult<unknown>> {
-    return Promise.resolve({
-      data: {},
-      rawText: '{}',
-    })
-  }
-}
-
-class MockSummarizeAdapter<
-  TModel extends MockModel = 'model-a',
-> extends BaseSummarizeAdapter<TModel, Record<string, unknown>> {
-  readonly kind = 'summarize' as const
-  readonly name = 'mock' as const
-
-  private mockResult: SummarizationResult
-
-  constructor(
-    mockResult?: SummarizationResult,
-    model: TModel = 'model-a' as TModel,
-  ) {
-    super({}, model)
-    this.mockResult = mockResult ?? {
-      id: 'test-id',
-      model: model,
-      summary: 'This is a summary.',
-      usage: { promptTokens: 100, completionTokens: 20, totalTokens: 120 },
-    }
-  }
-
-  summarize(_options: SummarizationOptions): Promise<SummarizationResult> {
-    return Promise.resolve(this.mockResult)
-  }
-}
-
-describe('generate function', () => {
-  describe('with chat adapter', () => {
-    it('should return an async iterable of StreamChunks', async () => {
-      const mockChunks: Array<StreamChunk> = [
-        {
-          type: 'content',
-          id: '1',
-          model: 'model-a',
-          delta: 'Hello',
-          content: 'Hello',
-          timestamp: Date.now(),
-        },
-        {
-          type: 'content',
-          id: '2',
-          model: 'model-a',
-          delta: ' world',
-          content: 'Hello world',
-          timestamp: Date.now(),
-        },
-        {
-          type: 'done',
-          id: '3',
-          model: 'model-a',
-          timestamp: Date.now(),
-          finishReason: 'stop',
-        },
-      ]
-
-      const adapter = new MockTextAdapter(mockChunks)
-      const messages: Array<ModelMessage> = [
-        { role: 'user', content: [{ type: 'text', content: 'Hi' }] },
-      ]
-
-      const result = chat({
-        adapter,
-        messages,
-      })
-
-      // Result should be an async iterable
-      expect(result).toBeDefined()
-      expect(typeof result[Symbol.asyncIterator]).toBe('function')
-
-      // Collect all chunks
-      const collected: Array<StreamChunk> = []
-      for await (const chunk of result) {
-        collected.push(chunk)
-      }
-
-      expect(collected).toHaveLength(3)
-      expect(collected[0]?.type).toBe('content')
-      expect(collected[2]?.type).toBe('done')
-    })
-
-    it('should pass options to the text adapter', async () => {
-      const adapter = new MockTextAdapter([])
-      const chatStreamSpy = vi.spyOn(adapter, 'chatStream')
-
-      const messages: Array<ModelMessage> = [
-        { role: 'user', content: [{ type: 'text', content: 'Test message' }] },
-      ]
-
-      // Consume the iterable to trigger the method
-      const result = chat({
-        adapter,
-        messages,
-        systemPrompts: ['Be helpful'],
-        temperature: 0.7,
-      })
-      for await (const _ of result) {
-        // Consume
-      }
-
-      expect(chatStreamSpy).toHaveBeenCalled()
-    })
-  })
-
-  describe('with summarize adapter', () => {
-    it('should return a SummarizationResult', async () => {
-      const expectedResult: SummarizationResult = {
-        id: 'sum-456',
-        model: 'model-b',
-        summary: 'A concise summary of the text.',
-        usage: { promptTokens: 200, completionTokens: 30, totalTokens: 230 },
-      }
-
-      const adapter = new MockSummarizeAdapter(expectedResult, 'model-b')
-
-      const result = await summarize({
-        adapter,
-        text: 'Long text to summarize...',
-      })
-
-      expect(result).toEqual(expectedResult)
-    })
-
-    it('should pass options to the summarize adapter', async () => {
-      const adapter = new MockSummarizeAdapter()
-      const summarizeSpy = vi.spyOn(adapter, 'summarize')
-
-      await summarize({
-        adapter,
-        text: 'Some text to summarize',
-        style: 'bullet-points',
-        maxLength: 100,
-      })
-
-      expect(summarizeSpy).toHaveBeenCalled()
-    })
-  })
-
-  describe('type safety', () => {
-    it('should have proper return type inference for text adapter', () => {
-      const adapter = new MockTextAdapter([])
-      const messages: Array<ModelMessage> = []
-
-      // TypeScript should infer AsyncIterable<StreamChunk>
-      const result = chat({
-        adapter,
-        messages,
-      })
-
-      // This ensures the type is AsyncIterable, not Promise
-      expect(typeof result[Symbol.asyncIterator]).toBe('function')
-    })
-
-    it('should have proper return type inference for summarize adapter', () => {
-      const adapter = new MockSummarizeAdapter()
-
-      // TypeScript should infer Promise<SummarizationResult>
-      const result = summarize({
-        adapter,
-        text: 'test',
-      })
-
-      // This ensures the type is Promise
-      expect(result).toBeInstanceOf(Promise)
-    })
-  })
-})
diff --git a/packages/typescript/ai/tests/per-model-type-safety.test.ts b/packages/typescript/ai/tests/per-model-type-safety.test.ts
deleted file mode 100644
index c83d57de..00000000
--- a/packages/typescript/ai/tests/per-model-type-safety.test.ts
+++ /dev/null
@@ -1,972 +0,0 @@
-/**
- * Type Safety Tests for chat() function
- *
- * These tests verify that the chat() function correctly constrains types based on:
- * 1. Model-specific provider options (modelOptions)
- * 2. Model-specific input modalities (message content types)
- * 3. Model-specific message metadata (e.g., detail for images)
- *
- * Uses @ts-expect-error to ensure TypeScript catches invalid type combinations.
- */
-import { describe, expectTypeOf, it } from 'vitest'
-import { BaseTextAdapter } from '../src/activities/chat/adapter'
-import { chat } from '../src/activities/chat'
-import type { StreamChunk, TextOptions } from '../src/types'
-import type {
-  StructuredOutputOptions,
-  StructuredOutputResult,
-} from '../src/activities/chat/adapter'
-
-// ===========================
-// Mock Provider Options Types
-// ===========================
-
-/**
- * Base options available to ALL mock models
- */
-interface MockBaseOptions {
-  availableOnAllModels?: boolean
-}
-
-/**
- * Reasoning options - only available to advanced models like mock-gpt-5
- */
-interface MockReasoningOptions {
-  reasoning?: {
-    effort?: 'none' | 'low' | 'medium' | 'high'
-    summary?: 'auto' | 'detailed'
-  }
-}
-
-/**
- * Structured output options - only available to advanced models
- */
-interface MockStructuredOutputOptions {
-  text?: {
-    format?: { type: 'json_schema'; json_schema: Record<string, unknown> }
-  }
-}
-
-/**
- * Tools options - only available to advanced models
- */
-interface MockToolsOptions {
-  tool_choice?: 'auto' | 'none' | 'required'
-  parallel_tool_calls?: boolean
-}
-
-/**
- * Streaming options
- */
-interface MockStreamingOptions {
-  stream_options?: {
-    include_obfuscation?: boolean
-  }
-}
-
-// ===========================
-// Mock Model Metadata
-// ===========================
-
-/**
- * Metadata for mock image content parts.
- */
-interface MockImageMetadata {
-  /**
-   * Controls how the model processes the image.
-   */
-  detail?: 'auto' | 'low' | 'high'
-}
-
-/**
- * Metadata for mock audio content parts.
- */
-interface MockAudioMetadata {
-  format?: 'mp3' | 'wav' | 'flac'
-}
-
-/**
- * Metadata for mock text content parts - no specific options
- */
-interface MockTextMetadata {}
-
-/**
- * Metadata for mock video content parts - no specific options
- */
-interface MockVideoMetadata {}
-
-/**
- * Metadata for mock document content parts - no specific options
- */
-interface MockDocumentMetadata {}
-
-/**
- * Map of modality types to their mock-specific metadata types.
- */
-interface MockMessageMetadataByModality {
-  text: MockTextMetadata
-  image: MockImageMetadata
-  audio: MockAudioMetadata
-  video: MockVideoMetadata
-  document: MockDocumentMetadata
-}
-
-// ===========================
-// Mock Model Definitions
-// ===========================
-
-/**
- * mock-gpt-5: Advanced model with full features
- * - Supports: text + image input
- * - Has: reasoning, structured output, tools, streaming options
- */
-const MOCK_GPT_5 = {
-  name: 'mock-gpt-5',
-  supports: {
-    input: ['text', 'image'] as const,
-    output: ['text'] as const,
-  },
-} as const
-
-/**
- * mock-gpt-3.5-turbo: Basic model with limited features
- * - Supports: text-only input
- * - Has: base options only (no reasoning, no structured output, no tools)
- */
-const MOCK_GPT_3_5_TURBO = {
-  name: 'mock-gpt-3.5-turbo',
-  supports: {
-    input: ['text'] as const,
-    output: ['text'] as const,
-  },
-} as const
-
-// ===========================
-// Mock Model Types
-// ===========================
-
-/**
- * List of available mock chat models
- */
-const MOCK_CHAT_MODELS = [MOCK_GPT_5.name, MOCK_GPT_3_5_TURBO.name] as const
-
-type MockChatModel = (typeof MOCK_CHAT_MODELS)[number]
-
-/**
- * Type map: model name -> provider options
- */
-type MockChatModelProviderOptionsByName = {
-  'mock-gpt-5': MockBaseOptions &
-    MockReasoningOptions &
-    MockStructuredOutputOptions &
-    MockToolsOptions &
-    MockStreamingOptions
-  'mock-gpt-3.5-turbo': MockBaseOptions & MockStreamingOptions
-}
-
-/**
- * Type map: model name -> input modalities
- */
-type MockModelInputModalitiesByName = {
-  'mock-gpt-5': typeof MOCK_GPT_5.supports.input
-  'mock-gpt-3.5-turbo': typeof MOCK_GPT_3_5_TURBO.supports.input
-}
-
-// ===========================
-// Type Resolution Helpers
-// ===========================
-
-/**
- * Resolve provider options for a specific mock model.
- */
-type ResolveProviderOptions<TModel extends string> =
-  TModel extends keyof MockChatModelProviderOptionsByName
-    ? MockChatModelProviderOptionsByName[TModel]
-    : MockBaseOptions
-
-/**
- * Resolve input modalities for a specific mock model.
- */
-type ResolveInputModalities<TModel extends string> =
-  TModel extends keyof MockModelInputModalitiesByName
-    ? MockModelInputModalitiesByName[TModel]
-    : readonly ['text', 'image', 'audio']
-
-// ===========================
-// Mock Adapter Implementation
-// ===========================
-
-/**
- * Mock Text Adapter - simulates OpenAI adapter structure
- */
-class MockTextAdapter<TModel extends MockChatModel> extends BaseTextAdapter<
-  TModel,
-  ResolveProviderOptions<TModel>,
-  ResolveInputModalities<TModel>,
-  MockMessageMetadataByModality
-> {
-  readonly kind = 'text' as const
-  readonly name = 'mock' as const
-
-  constructor(model: TModel) {
-    super({}, model)
-  }
-
-  /* eslint-disable @typescript-eslint/require-await */
-  async *chatStream(
-    _options: TextOptions<ResolveProviderOptions<TModel>>,
-  ): AsyncIterable<StreamChunk> {
-    yield {
-      type: 'content',
-      model: this.model,
-      id: 'mock-id',
-      timestamp: Date.now(),
-      delta: 'Hello',
-      content: 'Hello',
-      role: 'assistant',
-    }
-    yield {
-      type: 'done',
-      model: this.model,
-      id: 'mock-id',
-      timestamp: Date.now(),
-      finishReason: 'stop',
-    }
-  }
-  /* eslint-enable @typescript-eslint/require-await */
-
-  /* eslint-disable @typescript-eslint/require-await */
-  async structuredOutput(
-    _options: StructuredOutputOptions<ResolveProviderOptions<TModel>>,
-  ): Promise<StructuredOutputResult<unknown>> {
-    return { data: {}, rawText: '{}' }
-  }
-  /* eslint-enable @typescript-eslint/require-await */
-}
-
-/**
- * Factory function to create mock adapters with proper type inference
- */
-function mockText<TModel extends MockChatModel>(
-  model: TModel,
-): MockTextAdapter<TModel> {
-  return new MockTextAdapter(model)
-}
-
-// ===========================
-// Type Safety Tests
-// ===========================
-
-describe('Type Safety Tests for chat() function', () => {
-  describe('Provider Options (modelOptions) Type Safety', () => {
-    it('should allow passing in common options', () => {
-      chat({
-        adapter: mockText('mock-gpt-5'),
-        messages: [{ role: 'user', content: 'Hello' }],
-        temperature: 0.7,
-      })
-      chat({
-        adapter: mockText('mock-gpt-3.5-turbo'),
-        messages: [{ role: 'user', content: 'Hello' }],
-        temperature: 0.7,
-      })
-    })
-
-    it('should not allow arbitrary keys in chat options', () => {
-      chat({
-        adapter: mockText('mock-gpt-5'),
-        messages: [{ role: 'user', content: 'Hello' }],
-        // @ts-expect-error - invalid chat option
-        random: true,
-      })
-      chat({
-        adapter: mockText('mock-gpt-3.5-turbo'),
-        messages: [{ role: 'user', content: 'Hello' }],
-        // @ts-expect-error - invalid chat option
-        random: true,
-      })
-    })
-
-    it('common options only accept valid keys at root level', () => {
-      chat({
-        adapter: mockText('mock-gpt-5'),
-        messages: [{ role: 'user', content: 'Hello' }],
-        temperature: 0.7,
-        // @ts-expect-error - invalid option at root level
-        random_option: true,
-      })
-      chat({
-        adapter: mockText('mock-gpt-3.5-turbo'),
-        messages: [{ role: 'user', content: 'Hello' }],
-        temperature: 0.7,
-        // @ts-expect-error - invalid option at root level
-        random_option: true,
-      })
-    })
-    describe('mock-gpt-5 (full featured model)', () => {
-      it('should allow reasoning options', () => {
-        // This should compile - mock-gpt-5 supports reasoning
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [{ role: 'user', content: 'Hello' }],
-          modelOptions: {
-            reasoning: {
-              effort: 'high',
-              summary: 'detailed',
-            },
-          },
-        })
-      })
-
-      it('should allow tool options', () => {
-        // This should compile - mock-gpt-5 supports tools
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [{ role: 'user', content: 'Hello' }],
-          modelOptions: {
-            tool_choice: 'auto',
-            parallel_tool_calls: true,
-          },
-        })
-      })
-
-      it('should allow structured output options', () => {
-        // This should compile - mock-gpt-5 supports structured output
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [{ role: 'user', content: 'Hello' }],
-          modelOptions: {
-            text: {
-              format: {
-                type: 'json_schema',
-                json_schema: { type: 'object' },
-              },
-            },
-          },
-        })
-      })
-
-      it('should allow base options', () => {
-        // This should compile - all models support base options
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [{ role: 'user', content: 'Hello' }],
-          modelOptions: {
-            availableOnAllModels: true,
-          },
-        })
-      })
-
-      it('should NOT allow unknown options', () => {
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [{ role: 'user', content: 'Hello' }],
-          modelOptions: {
-            // @ts-expect-error - 'unknownOption' does not exist on mock-gpt-5 provider options
-            unknownOption: true,
-          },
-        })
-      })
-    })
-
-    describe('mock-gpt-3.5-turbo (limited model)', () => {
-      it('should allow base options', () => {
-        // This should compile - all models support base options
-        chat({
-          adapter: mockText('mock-gpt-3.5-turbo'),
-          messages: [{ role: 'user', content: 'Hello' }],
-          modelOptions: {
-            availableOnAllModels: true,
-          },
-        })
-      })
-
-      it('should allow streaming options', () => {
-        // This should compile - mock-gpt-3.5-turbo supports streaming options
-        chat({
-          adapter: mockText('mock-gpt-3.5-turbo'),
-          messages: [{ role: 'user', content: 'Hello' }],
-          modelOptions: {
-            stream_options: {
-              include_obfuscation: true,
-            },
-          },
-        })
-      })
-
-      it('should NOT allow reasoning options', () => {
-        chat({
-          adapter: mockText('mock-gpt-3.5-turbo'),
-          messages: [{ role: 'user', content: 'Hello' }],
-          modelOptions: {
-            // @ts-expect-error - 'reasoning' does not exist on mock-gpt-3.5-turbo provider options
-            reasoning: {
-              effort: 'high',
-            },
-          },
-        })
-      })
-
-      it('should NOT allow tool_choice option', () => {
-        chat({
-          adapter: mockText('mock-gpt-3.5-turbo'),
-          messages: [{ role: 'user', content: 'Hello' }],
-          modelOptions: {
-            // @ts-expect-error - 'tool_choice' does not exist on mock-gpt-3.5-turbo provider options
-            tool_choice: 'auto',
-          },
-        })
-      })
-
-      it('should NOT allow parallel_tool_calls option', () => {
-        chat({
-          adapter: mockText('mock-gpt-3.5-turbo'),
-          messages: [{ role: 'user', content: 'Hello' }],
-          modelOptions: {
-            // @ts-expect-error - 'parallel_tool_calls' does not exist on mock-gpt-3.5-turbo provider options
-            parallel_tool_calls: true,
-          },
-        })
-      })
-
-      it('should NOT allow text/structured output options', () => {
-        chat({
-          adapter: mockText('mock-gpt-3.5-turbo'),
-          messages: [{ role: 'user', content: 'Hello' }],
-          modelOptions: {
-            // @ts-expect-error - 'text' does not exist on mock-gpt-3.5-turbo provider options
-            text: {
-              format: { type: 'json_schema', json_schema: {} },
-            },
-          },
-        })
-      })
-    })
-  })
-
-  describe('Input Modalities Type Safety', () => {
-    describe('mock-gpt-5 (text + image)', () => {
-      it('should allow text content', () => {
-        // This should compile - mock-gpt-5 supports text
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [{ role: 'user', content: 'Hello' }],
-        })
-      })
-
-      it('should allow text content part', () => {
-        // This should compile - mock-gpt-5 supports text
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [{ type: 'text', content: 'Hello' }],
-            },
-          ],
-        })
-      })
-
-      it('should allow image content part', () => {
-        // This should compile - mock-gpt-5 supports image
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                { type: 'text', content: 'Describe this image:' },
-                {
-                  type: 'image',
-                  source: {
-                    type: 'url',
-                    value: 'https://example.com/image.png',
-                  },
-                },
-              ],
-            },
-          ],
-        })
-      })
-
-      it('should allow image metadata (detail)', () => {
-        // This should compile - mock-gpt-5 supports image with detail metadata
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  type: 'image',
-                  source: {
-                    type: 'url',
-                    value: 'https://example.com/image.png',
-                  },
-                  metadata: { detail: 'high' },
-                },
-              ],
-            },
-          ],
-        })
-      })
-
-      it('should NOT allow audio content part', () => {
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  // @ts-expect-error - mock-gpt-5 does not support audio input
-                  type: 'audio',
-                  source: { type: 'data', value: 'base64data' },
-                },
-              ],
-            },
-          ],
-        })
-      })
-
-      it('should NOT allow video content part', () => {
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  // @ts-expect-error - mock-gpt-5 does not support video input
-                  type: 'video',
-                  source: {
-                    type: 'url',
-                    value: 'https://example.com/video.mp4',
-                  },
-                },
-              ],
-            },
-          ],
-        })
-      })
-
-      it('should NOT allow document content part', () => {
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  // @ts-expect-error - mock-gpt-5 does not support document input
-                  type: 'document',
-                  source: {
-                    type: 'url',
-                    value: 'https://example.com/doc.pdf',
-                  },
-                },
-              ],
-            },
-          ],
-        })
-      })
-    })
-
-    describe('mock-gpt-3.5-turbo (text only)', () => {
-      it('should allow text content', () => {
-        // This should compile - mock-gpt-3.5-turbo supports text
-        chat({
-          adapter: mockText('mock-gpt-3.5-turbo'),
-          messages: [{ role: 'user', content: 'Hello' }],
-        })
-      })
-
-      it('should allow text content part', () => {
-        // This should compile - mock-gpt-3.5-turbo supports text
-        chat({
-          adapter: mockText('mock-gpt-3.5-turbo'),
-          messages: [
-            {
-              role: 'user',
-              content: [{ type: 'text', content: 'Hello' }],
-            },
-          ],
-        })
-      })
-
-      it('should NOT allow image content part', () => {
-        chat({
-          adapter: mockText('mock-gpt-3.5-turbo'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  // @ts-expect-error - mock-gpt-3.5-turbo does not support image input
-                  type: 'image',
-                  source: {
-                    type: 'url',
-                    value: 'https://example.com/image.png',
-                  },
-                },
-              ],
-            },
-          ],
-        })
-      })
-
-      it('should NOT allow audio content part', () => {
-        chat({
-          adapter: mockText('mock-gpt-3.5-turbo'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  // @ts-expect-error - mock-gpt-3.5-turbo does not support audio input
-                  type: 'audio',
-                  source: {
-                    type: 'base64',
-                    value: 'base64data',
-                    mediaType: 'audio/mp3',
-                  },
-                },
-              ],
-            },
-          ],
-        })
-      })
-
-      it('should NOT allow video content part', () => {
-        chat({
-          adapter: mockText('mock-gpt-3.5-turbo'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  // @ts-expect-error - mock-gpt-3.5-turbo does not support video input
-                  type: 'video',
-                  source: {
-                    type: 'url',
-                    value: 'https://example.com/video.mp4',
-                  },
-                },
-              ],
-            },
-          ],
-        })
-      })
-
-      it('should NOT allow document content part', () => {
-        chat({
-          adapter: mockText('mock-gpt-3.5-turbo'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  // @ts-expect-error - mock-gpt-3.5-turbo does not support document input
-                  type: 'document',
-                  source: {
-                    type: 'url',
-                    value: 'https://example.com/doc.pdf',
-                  },
-                },
-              ],
-            },
-          ],
-        })
-      })
-    })
-  })
-
-  describe('Message Metadata Type Safety', () => {
-    describe('mock-gpt-5 image metadata', () => {
-      it('should allow valid detail values', () => {
-        // This should compile - 'auto', 'low', 'high' are valid detail values
-        const _stream1 = chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  type: 'image',
-                  source: {
-                    type: 'url',
-                    value: 'https://example.com/image.png',
-                  },
-                  metadata: { detail: 'auto' },
-                },
-              ],
-            },
-          ],
-        })
-
-        const _stream2 = chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  type: 'image',
-                  source: {
-                    type: 'url',
-                    value: 'https://example.com/image.png',
-                  },
-                  metadata: { detail: 'low' },
-                },
-              ],
-            },
-          ],
-        })
-
-        const _stream3 = chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  type: 'image',
-                  source: {
-                    type: 'url',
-                    value: 'https://example.com/image.png',
-                  },
-                  metadata: { detail: 'high' },
-                },
-              ],
-            },
-          ],
-        })
-
-        expectTypeOf(_stream1).toBeObject()
-        expectTypeOf(_stream2).toBeObject()
-        expectTypeOf(_stream3).toBeObject()
-      })
-
-      it('should NOT allow invalid detail values', () => {
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                // @ts-expect-error - 'ultra' is not a valid detail value
-                {
-                  type: 'image',
-                  source: {
-                    type: 'url',
-                    value: 'https://example.com/image.png',
-                  },
-                  metadata: { detail: 'ultra' },
-                },
-              ],
-            },
-          ],
-        })
-      })
-
-      it('should NOT allow unknown metadata properties on image', () => {
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [
-                {
-                  type: 'image',
-                  source: {
-                    type: 'url',
-                    value: 'https://example.com/image.png',
-                  },
-                  // @ts-expect-error - 'quality' is not a valid metadata property for images
-                  metadata: { quality: 'hd' },
-                },
-              ],
-            },
-          ],
-        })
-      })
-    })
-
-    describe('text metadata (should have no specific options)', () => {
-      it('should allow text without metadata', () => {
-        // This should compile - text doesn't require metadata
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [{ type: 'text', content: 'Hello' }],
-            },
-          ],
-        })
-      })
-
-      it('should allow text with empty metadata', () => {
-        // This should compile - empty metadata is fine
-        chat({
-          adapter: mockText('mock-gpt-5'),
-          messages: [
-            {
-              role: 'user',
-              content: [{ type: 'text', content: 'Hello', metadata: {} }],
-            },
-          ],
-        })
-      })
-    })
-  })
-
-  describe('Model Name Type Safety', () => {
-    it('should accept valid model names', () => {
-      // These should compile
-      const _adapter1 = mockText('mock-gpt-5')
-      const _adapter2 = mockText('mock-gpt-3.5-turbo')
-      expectTypeOf(_adapter1).toBeObject()
-      expectTypeOf(_adapter2).toBeObject()
-    })
-
-    it('should NOT accept invalid model names', () => {
-      // @ts-expect-error - 'invalid-model' is not a valid mock model name
-      const _adapter = mockText('invalid-model')
-    })
-  })
-
-  describe('Combined Scenarios', () => {
-    it('mock-gpt-5: full featured call should work', () => {
-      // This should compile - using all features available to mock-gpt-5
-      chat({
-        adapter: mockText('mock-gpt-5'),
-        messages: [
-          {
-            role: 'user',
-            content: [
-              { type: 'text', content: 'Analyze this image:' },
-              {
-                type: 'image',
-                source: { type: 'url', value: 'https://example.com/image.png' },
-                metadata: { detail: 'high' },
-              },
-            ],
-          },
-        ],
-        modelOptions: {
-          reasoning: {
-            effort: 'medium',
-            summary: 'auto',
-          },
-          tool_choice: 'auto',
-          parallel_tool_calls: true,
-        },
-        systemPrompts: ['You are a helpful assistant.'],
-      })
-    })
-
-    it('mock-gpt-3.5-turbo: should error with advanced features', () => {
-      chat({
-        adapter: mockText('mock-gpt-3.5-turbo'),
-        messages: [
-          {
-            role: 'user',
-            content: [
-              {
-                // @ts-expect-error - mock-gpt-3.5-turbo doesn't support reasoning OR image input
-                type: 'image',
-                source: { type: 'url', value: 'https://example.com/image.png' },
-              },
-            ],
-          },
-        ],
-        modelOptions: {
-          // @ts-expect-error - mock-gpt-3.5-turbo doesn't support reasoning options
-          reasoning: { effort: 'high' },
-        },
-      })
-    })
-
-    it('mock-gpt-3.5-turbo: basic call should work', () => {
-      // This should compile - using only features available to mock-gpt-3.5-turbo
-      chat({
-        adapter: mockText('mock-gpt-3.5-turbo'),
-        messages: [{ role: 'user', content: 'Hello!' }],
-        modelOptions: {
-          availableOnAllModels: true,
-        },
-        systemPrompts: ['You are a helpful assistant.'],
-      })
-    })
-  })
-})
-
-describe('Provider Options Type Assertions', () => {
-  describe('mock-gpt-5 should extend all option interfaces', () => {
-    it('should have reasoning options', () => {
-      type Options = MockChatModelProviderOptionsByName['mock-gpt-5']
-      expectTypeOf<Options>().toHaveProperty('reasoning')
-    })
-
-    it('should have tool options', () => {
-      type Options = MockChatModelProviderOptionsByName['mock-gpt-5']
-      expectTypeOf<Options>().toHaveProperty('tool_choice')
-      expectTypeOf<Options>().toHaveProperty('parallel_tool_calls')
-    })
-
-    it('should have structured output options', () => {
-      type Options = MockChatModelProviderOptionsByName['mock-gpt-5']
-      expectTypeOf<Options>().toHaveProperty('text')
-    })
-
-    it('should have base options', () => {
-      type Options = MockChatModelProviderOptionsByName['mock-gpt-5']
-      expectTypeOf<Options>().toHaveProperty('availableOnAllModels')
-    })
-  })
-
-  describe('mock-gpt-3.5-turbo should only have limited options', () => {
-    it('should NOT have reasoning options', () => {
-      type Options = MockChatModelProviderOptionsByName['mock-gpt-3.5-turbo']
-      // Reasoning should not be a property
-      expectTypeOf<Options>().not.toHaveProperty('reasoning')
-    })
-
-    it('should NOT have tool options', () => {
-      type Options = MockChatModelProviderOptionsByName['mock-gpt-3.5-turbo']
-      expectTypeOf<Options>().not.toHaveProperty('tool_choice')
-      expectTypeOf<Options>().not.toHaveProperty('parallel_tool_calls')
-    })
-
-    it('should NOT have structured output options', () => {
-      type Options = MockChatModelProviderOptionsByName['mock-gpt-3.5-turbo']
-      expectTypeOf<Options>().not.toHaveProperty('text')
-    })
-
-    it('should have base options', () => {
-      type Options = MockChatModelProviderOptionsByName['mock-gpt-3.5-turbo']
-      expectTypeOf<Options>().toHaveProperty('availableOnAllModels')
-    })
-  })
-})
-
-describe('Input Modalities Type Assertions', () => {
-  describe('mock-gpt-5 (text + image)', () => {
-    type Modalities = MockModelInputModalitiesByName['mock-gpt-5']
-
-    it('should support text and image', () => {
-      // Verify the modalities array contains exactly text and image
-      expectTypeOf<Modalities>().toEqualTypeOf<readonly ['text', 'image']>()
-    })
-  })
-
-  describe('mock-gpt-3.5-turbo (text only)', () => {
-    type Modalities = MockModelInputModalitiesByName['mock-gpt-3.5-turbo']
-
-    it('should only support text', () => {
-      // Verify the modalities array contains only text
-      expectTypeOf<Modalities>().toEqualTypeOf<readonly ['text']>()
-    })
-  })
-})
diff --git a/packages/typescript/ai/tests/stream-processor-edge-cases.test.ts b/packages/typescript/ai/tests/stream-processor-edge-cases.test.ts
deleted file mode 100644
index f8e2989d..00000000
--- a/packages/typescript/ai/tests/stream-processor-edge-cases.test.ts
+++ /dev/null
@@ -1,1173 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { StreamProcessor } from '../src/activities/chat/stream'
-import type {
-  StreamProcessorEvents,
-  StreamProcessorHandlers,
-} from '../src/activities/chat/stream'
-
-describe('StreamProcessor Edge Cases and Real-World Scenarios', () => {
-  describe('Content Chunk Delta/Content Fallback Logic', () => {
-    it('should handle content-only chunks when delta is empty', () => {
-      const handlers: StreamProcessorHandlers = {
-        onTextUpdate: vi.fn(),
-      }
-      const events: StreamProcessorEvents = {
-        onTextUpdate: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-        events,
-      })
-
-      processor.startAssistantMessage()
-
-      // First chunk with delta
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Hello',
-        content: 'Hello',
-        role: 'assistant',
-      })
-
-      // Second chunk with only content (no delta) - should use content fallback
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: '', // Empty delta
-        content: 'Hello world', // Full content
-        role: 'assistant',
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      const textPart = assistantMsg?.parts.find((p) => p.type === 'text')
-
-      expect(textPart?.type).toBe('text')
-      if (textPart?.type === 'text') {
-        expect(textPart.content).toBe('Hello world')
-      }
-    })
-
-    it('should handle content that starts with current text', () => {
-      const processor = new StreamProcessor({})
-      processor.startAssistantMessage()
-
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Hello',
-        content: 'Hello',
-        role: 'assistant',
-      })
-
-      // Content starts with current text - should use content
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: '',
-        content: 'Hello world', // Starts with "Hello"
-        role: 'assistant',
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      const textPart = assistantMsg?.parts.find((p) => p.type === 'text')
-
-      expect(textPart?.type).toBe('text')
-      if (textPart?.type === 'text') {
-        expect(textPart.content).toBe('Hello world')
-      }
-    })
-
-    it('should handle content that current text starts with', () => {
-      const processor = new StreamProcessor({})
-      processor.startAssistantMessage()
-
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Hello world',
-        content: 'Hello world',
-        role: 'assistant',
-      })
-
-      // Current text starts with content - should keep current text
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: '',
-        content: 'Hello', // Shorter than current "Hello world"
-        role: 'assistant',
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      const textPart = assistantMsg?.parts.find((p) => p.type === 'text')
-
-      expect(textPart?.type).toBe('text')
-      if (textPart?.type === 'text') {
-        expect(textPart.content).toBe('Hello world') // Should keep longer text
-      }
-    })
-
-    it('should concatenate content when neither starts with the other', () => {
-      const processor = new StreamProcessor({})
-      processor.startAssistantMessage()
-
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Hello',
-        content: 'Hello',
-        role: 'assistant',
-      })
-
-      // Content doesn't start with current, current doesn't start with content
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: '',
-        content: 'world', // Different from "Hello"
-        role: 'assistant',
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      const textPart = assistantMsg?.parts.find((p) => p.type === 'text')
-
-      expect(textPart?.type).toBe('text')
-      if (textPart?.type === 'text') {
-        expect(textPart.content).toBe('Helloworld') // Concatenated
-      }
-    })
-  })
-
-  describe('Tool Result Chunk Handling', () => {
-    it('should handle tool result chunks and update UIMessage', () => {
-      const handlers: StreamProcessorHandlers = {
-        onToolResultStateChange: vi.fn(),
-      }
-      const events: StreamProcessorEvents = {
-        onMessagesChange: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-        events,
-      })
-
-      processor.startAssistantMessage()
-
-      // First, add a tool call
-      processor.processChunk({
-        type: 'tool_call',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCall: {
-          id: 'call-1',
-          type: 'function',
-          function: { name: 'getWeather', arguments: '{"location":"Paris"}' },
-        },
-        index: 0,
-      })
-
-      // Then process tool result
-      processor.processChunk({
-        type: 'tool_result',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        content: '{"temperature":20,"conditions":"sunny"}',
-      })
-
-      expect(handlers.onToolResultStateChange).toHaveBeenCalledWith(
-        'call-1',
-        '{"temperature":20,"conditions":"sunny"}',
-        'complete',
-      )
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      const toolResultPart = assistantMsg?.parts.find(
-        (p) => p.type === 'tool-result' && p.toolCallId === 'call-1',
-      )
-
-      expect(toolResultPart?.type).toBe('tool-result')
-      if (toolResultPart?.type === 'tool-result') {
-        expect(toolResultPart.content).toBe(
-          '{"temperature":20,"conditions":"sunny"}',
-        )
-        expect(toolResultPart.state).toBe('complete')
-      }
-
-      expect(events.onMessagesChange).toHaveBeenCalled()
-    })
-
-    it('should handle tool result without current assistant message', () => {
-      const handlers: StreamProcessorHandlers = {
-        onToolResultStateChange: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({ handlers })
-
-      // Process tool result without starting assistant message
-      processor.processChunk({
-        type: 'tool_result',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        content: '{"result":"test"}',
-      })
-
-      // Handler should still be called
-      expect(handlers.onToolResultStateChange).toHaveBeenCalled()
-      // But message shouldn't be updated
-      expect(processor.getMessages()).toHaveLength(0)
-    })
-  })
-
-  describe('Thinking Chunk Delta/Content Fallback Logic', () => {
-    it('should handle thinking chunks with delta', () => {
-      const handlers: StreamProcessorHandlers = {
-        onThinkingUpdate: vi.fn(),
-      }
-      const events: StreamProcessorEvents = {
-        onThinkingUpdate: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-        events,
-      })
-
-      processor.startAssistantMessage()
-
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Let me think',
-        content: 'Let me think',
-      })
-
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: ' about this',
-        content: 'Let me think about this',
-      })
-
-      expect(handlers.onThinkingUpdate).toHaveBeenCalledWith(
-        'Let me think about this',
-      )
-      expect(events.onThinkingUpdate).toHaveBeenCalledWith(
-        expect.any(String),
-        'Let me think about this',
-      )
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      const thinkingPart = assistantMsg?.parts.find(
-        (p) => p.type === 'thinking',
-      )
-
-      expect(thinkingPart?.type).toBe('thinking')
-      if (thinkingPart?.type === 'thinking') {
-        expect(thinkingPart.content).toBe('Let me think about this')
-      }
-    })
-
-    it('should handle thinking chunks with content-only fallback', () => {
-      const processor = new StreamProcessor({})
-      processor.startAssistantMessage()
-
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Let me think',
-        content: 'Let me think',
-      })
-
-      // Content-only chunk
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: '', // Empty delta
-        content: 'Let me think about this', // Full content
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      const thinkingPart = assistantMsg?.parts.find(
-        (p) => p.type === 'thinking',
-      )
-
-      expect(thinkingPart?.type).toBe('thinking')
-      if (thinkingPart?.type === 'thinking') {
-        expect(thinkingPart.content).toBe('Let me think about this')
-      }
-    })
-
-    it('should handle thinking content that starts with previous', () => {
-      const processor = new StreamProcessor({})
-      processor.startAssistantMessage()
-
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Let me',
-        content: 'Let me',
-      })
-
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: '',
-        content: 'Let me think', // Starts with "Let me"
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      const thinkingPart = assistantMsg?.parts.find(
-        (p) => p.type === 'thinking',
-      )
-
-      expect(thinkingPart?.type).toBe('thinking')
-      if (thinkingPart?.type === 'thinking') {
-        expect(thinkingPart.content).toBe('Let me think')
-      }
-    })
-
-    it('should handle thinking when previous starts with content', () => {
-      const processor = new StreamProcessor({})
-      processor.startAssistantMessage()
-
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Let me think about this',
-        content: 'Let me think about this',
-      })
-
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: '',
-        content: 'Let me', // Shorter than previous
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      const thinkingPart = assistantMsg?.parts.find(
-        (p) => p.type === 'thinking',
-      )
-
-      expect(thinkingPart?.type).toBe('thinking')
-      if (thinkingPart?.type === 'thinking') {
-        expect(thinkingPart.content).toBe('Let me think about this') // Keep longer
-      }
-    })
-
-    it('should concatenate thinking when neither starts with the other', () => {
-      const processor = new StreamProcessor({})
-      processor.startAssistantMessage()
-
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'First',
-        content: 'First',
-      })
-
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: '',
-        content: 'Second', // Different from "First"
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      const thinkingPart = assistantMsg?.parts.find(
-        (p) => p.type === 'thinking',
-      )
-
-      expect(thinkingPart?.type).toBe('thinking')
-      if (thinkingPart?.type === 'thinking') {
-        expect(thinkingPart.content).toBe('FirstSecond') // Concatenated
-      }
-    })
-  })
-
-  describe('Approval Requested Chunk Handling', () => {
-    it('should handle approval requested chunks and update UIMessage', () => {
-      const handlers: StreamProcessorHandlers = {
-        onApprovalRequested: vi.fn(),
-      }
-      const events: StreamProcessorEvents = {
-        onApprovalRequest: vi.fn(),
-        onMessagesChange: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-        events,
-      })
-
-      processor.startAssistantMessage()
-
-      // First add tool call
-      processor.processChunk({
-        type: 'tool_call',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCall: {
-          id: 'call-1',
-          type: 'function',
-          function: { name: 'deleteFile', arguments: '{"path":"/tmp/file"}' },
-        },
-        index: 0,
-      })
-
-      // Then request approval
-      processor.processChunk({
-        type: 'approval-requested',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        toolName: 'deleteFile',
-        input: { path: '/tmp/file' },
-        approval: {
-          id: 'approval-123',
-          needsApproval: true,
-        },
-      })
-
-      expect(handlers.onApprovalRequested).toHaveBeenCalledWith(
-        'call-1',
-        'deleteFile',
-        { path: '/tmp/file' },
-        'approval-123',
-      )
-
-      expect(events.onApprovalRequest).toHaveBeenCalledWith({
-        toolCallId: 'call-1',
-        toolName: 'deleteFile',
-        input: { path: '/tmp/file' },
-        approvalId: 'approval-123',
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      const toolCallPart = assistantMsg?.parts.find(
-        (p) => p.type === 'tool-call' && p.id === 'call-1',
-      ) as any
-
-      expect(toolCallPart?.state).toBe('approval-requested')
-      expect(toolCallPart?.approval?.id).toBe('approval-123')
-      expect(toolCallPart?.approval?.needsApproval).toBe(true)
-
-      expect(events.onMessagesChange).toHaveBeenCalled()
-    })
-
-    it('should handle approval requested without current assistant message', () => {
-      const handlers: StreamProcessorHandlers = {
-        onApprovalRequested: vi.fn(),
-      }
-      const events: StreamProcessorEvents = {
-        onApprovalRequest: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-        events,
-      })
-
-      // Request approval without starting assistant message
-      processor.processChunk({
-        type: 'approval-requested',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        toolName: 'deleteFile',
-        input: { path: '/tmp/file' },
-        approval: {
-          id: 'approval-123',
-          needsApproval: true,
-        },
-      })
-
-      // Handlers should still be called
-      expect(handlers.onApprovalRequested).toHaveBeenCalled()
-      expect(events.onApprovalRequest).toHaveBeenCalled()
-      // But message shouldn't be updated
-      expect(processor.getMessages()).toHaveLength(0)
-    })
-  })
-
-  describe('Tool Input Available Chunk Handling', () => {
-    it('should handle tool input available chunks', () => {
-      const handlers: StreamProcessorHandlers = {
-        onToolInputAvailable: vi.fn(),
-      }
-      const events: StreamProcessorEvents = {
-        onToolCall: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-        events,
-      })
-
-      processor.processChunk({
-        type: 'tool-input-available',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        toolName: 'getWeather',
-        input: { location: 'Paris' },
-      })
-
-      expect(handlers.onToolInputAvailable).toHaveBeenCalledWith(
-        'call-1',
-        'getWeather',
-        { location: 'Paris' },
-      )
-
-      expect(events.onToolCall).toHaveBeenCalledWith({
-        toolCallId: 'call-1',
-        toolName: 'getWeather',
-        input: { location: 'Paris' },
-      })
-    })
-  })
-
-  describe('Complex Real-World Scenarios', () => {
-    it('should handle delta vs content field correctly in new segments', async () => {
-      const processor = new StreamProcessor({})
-      processor.startAssistantMessage()
-
-      // First content segment with delta
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Hello',
-        content: 'Hello',
-        role: 'assistant',
-      })
-
-      // Tool call
-      processor.processChunk({
-        type: 'tool_call',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCall: {
-          id: 'call-1',
-          type: 'function',
-          function: { name: 'getData', arguments: '{}' },
-        },
-        index: 0,
-      })
-
-      // New text segment after tool call - when content field includes full accumulated text
-      // and we're in a new segment, the content field represents the full text including previous segment
-      // The processor correctly handles this by detecting it's a new segment
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Done!',
-        content: 'HelloDone!', // Content includes full accumulated text
-        role: 'assistant',
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      const textParts = assistantMsg?.parts.filter((p) => p.type === 'text')
-
-      // Should have 2 text parts (before and after tool call)
-      expect(textParts).toHaveLength(2)
-      if (textParts?.[0]?.type === 'text') {
-        expect(textParts[0].content).toBe('Hello')
-      }
-      // When content field includes full accumulated text in a new segment,
-      // the processor uses the content field which includes both segments
-      if (textParts?.[1]?.type === 'text') {
-        expect(textParts[1].content).toBe('HelloDone!')
-      }
-    })
-
-    it('should handle content fallback + tool results in same stream', async () => {
-      const handlers: StreamProcessorHandlers = {
-        onTextUpdate: vi.fn(),
-        onToolResultStateChange: vi.fn(),
-      }
-      const events: StreamProcessorEvents = {
-        onTextUpdate: vi.fn(),
-        onMessagesChange: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-        events,
-      })
-
-      processor.startAssistantMessage()
-
-      // Content with delta
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Let me check',
-        content: 'Let me check',
-        role: 'assistant',
-      })
-
-      // Content with only content field (no delta)
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: '',
-        content: 'Let me check the weather',
-        role: 'assistant',
-      })
-
-      // Tool call
-      processor.processChunk({
-        type: 'tool_call',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCall: {
-          id: 'call-1',
-          type: 'function',
-          function: { name: 'getWeather', arguments: '{"location":"Paris"}' },
-        },
-        index: 0,
-      })
-
-      // Tool result
-      processor.processChunk({
-        type: 'tool_result',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        content: '{"temperature":20}',
-      })
-
-      // More content - this starts a new text segment after tool calls
-      // The content field includes full accumulated text, but we're in a new segment
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'The temperature is 20°C',
-        content: 'Let me check the weatherThe temperature is 20°C',
-        role: 'assistant',
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-
-      // Should have text, tool call, tool result, and more text
-      expect(assistantMsg?.parts).toHaveLength(4)
-      expect(assistantMsg?.parts[0]?.type).toBe('text')
-      expect(assistantMsg?.parts[1]?.type).toBe('tool-call')
-      expect(assistantMsg?.parts[2]?.type).toBe('tool-result')
-      expect(assistantMsg?.parts[3]?.type).toBe('text')
-
-      if (assistantMsg?.parts[0]?.type === 'text') {
-        expect(assistantMsg.parts[0].content).toBe('Let me check the weather')
-      }
-      // When content-only chunk comes after tool calls, content field includes full text
-      // but since it's a new segment starting empty, it uses the full content
-      if (assistantMsg?.parts[3]?.type === 'text') {
-        expect(assistantMsg.parts[3].content).toBe(
-          'Let me check the weatherThe temperature is 20°C',
-        )
-      }
-    })
-
-    it('should handle thinking + approval flow', async () => {
-      const handlers: StreamProcessorHandlers = {
-        onThinkingUpdate: vi.fn(),
-        onApprovalRequested: vi.fn(),
-      }
-      const events: StreamProcessorEvents = {
-        onThinkingUpdate: vi.fn(),
-        onApprovalRequest: vi.fn(),
-        onMessagesChange: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-        events,
-      })
-
-      processor.startAssistantMessage()
-
-      // Thinking with delta
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'I need to',
-        content: 'I need to',
-      })
-
-      // Thinking with content-only
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: '',
-        content: 'I need to delete this file',
-      })
-
-      // Tool call
-      processor.processChunk({
-        type: 'tool_call',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCall: {
-          id: 'call-1',
-          type: 'function',
-          function: { name: 'deleteFile', arguments: '{"path":"/tmp/file"}' },
-        },
-        index: 0,
-      })
-
-      // Approval request
-      processor.processChunk({
-        type: 'approval-requested',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        toolName: 'deleteFile',
-        input: { path: '/tmp/file' },
-        approval: {
-          id: 'approval-123',
-          needsApproval: true,
-        },
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-
-      // Should have thinking, tool call with approval
-      expect(assistantMsg?.parts).toHaveLength(2)
-      expect(assistantMsg?.parts[0]?.type).toBe('thinking')
-      expect(assistantMsg?.parts[1]?.type).toBe('tool-call')
-
-      if (assistantMsg?.parts[0]?.type === 'thinking') {
-        expect(assistantMsg.parts[0].content).toBe('I need to delete this file')
-      }
-
-      const toolCallPart = assistantMsg?.parts[1] as any
-      expect(toolCallPart?.state).toBe('approval-requested')
-      expect(toolCallPart?.approval?.id).toBe('approval-123')
-    })
-
-    it('should handle tool input available + approval + tool result flow', async () => {
-      const handlers: StreamProcessorHandlers = {
-        onToolInputAvailable: vi.fn(),
-        onApprovalRequested: vi.fn(),
-        onToolResultStateChange: vi.fn(),
-      }
-      const events: StreamProcessorEvents = {
-        onToolCall: vi.fn(),
-        onApprovalRequest: vi.fn(),
-        onMessagesChange: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-        events,
-      })
-
-      processor.startAssistantMessage()
-
-      // Tool input available
-      processor.processChunk({
-        type: 'tool-input-available',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        toolName: 'deleteFile',
-        input: { path: '/tmp/file' },
-      })
-
-      expect(handlers.onToolInputAvailable).toHaveBeenCalled()
-      expect(events.onToolCall).toHaveBeenCalled()
-
-      // Tool call
-      processor.processChunk({
-        type: 'tool_call',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCall: {
-          id: 'call-1',
-          type: 'function',
-          function: { name: 'deleteFile', arguments: '{"path":"/tmp/file"}' },
-        },
-        index: 0,
-      })
-
-      // Approval request
-      processor.processChunk({
-        type: 'approval-requested',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        toolName: 'deleteFile',
-        input: { path: '/tmp/file' },
-        approval: {
-          id: 'approval-123',
-          needsApproval: true,
-        },
-      })
-
-      expect(handlers.onApprovalRequested).toHaveBeenCalled()
-      expect(events.onApprovalRequest).toHaveBeenCalled()
-
-      // Tool result (after approval)
-      processor.processChunk({
-        type: 'tool_result',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        content: '{"success":true}',
-      })
-
-      expect(handlers.onToolResultStateChange).toHaveBeenCalledWith(
-        'call-1',
-        '{"success":true}',
-        'complete',
-      )
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-
-      // Should have tool call and tool result
-      const toolCallPart = assistantMsg?.parts.find(
-        (p) => p.type === 'tool-call' && (p as any).id === 'call-1',
-      ) as any
-      const toolResultPart = assistantMsg?.parts.find(
-        (p) => p.type === 'tool-result' && (p as any).toolCallId === 'call-1',
-      ) as any
-
-      expect(toolCallPart?.state).toBe('approval-requested')
-      expect(toolResultPart?.content).toBe('{"success":true}')
-      expect(toolResultPart?.state).toBe('complete')
-    })
-
-    it('should handle mixed content (delta and content) + thinking + tool results', async () => {
-      const processor = new StreamProcessor({})
-      processor.startAssistantMessage()
-
-      // Content with delta
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Hello',
-        content: 'Hello',
-        role: 'assistant',
-      })
-
-      // Content with only content field
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: '',
-        content: 'Hello world',
-        role: 'assistant',
-      })
-
-      // Thinking with delta
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Let me think',
-        content: 'Let me think',
-      })
-
-      // Thinking with only content
-      processor.processChunk({
-        type: 'thinking',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: '',
-        content: 'Let me think about this',
-      })
-
-      // Tool call
-      processor.processChunk({
-        type: 'tool_call',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCall: {
-          id: 'call-1',
-          type: 'function',
-          function: { name: 'getData', arguments: '{}' },
-        },
-        index: 0,
-      })
-
-      // Tool result
-      processor.processChunk({
-        type: 'tool_result',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        content: '{"result":"data"}',
-      })
-
-      // More content - this starts a new text segment after tool calls
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'Done!',
-        content: 'Hello worldDone!',
-        role: 'assistant',
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-
-      expect(assistantMsg?.parts).toHaveLength(5)
-      expect(assistantMsg?.parts[0]?.type).toBe('text')
-      expect(assistantMsg?.parts[1]?.type).toBe('thinking')
-      expect(assistantMsg?.parts[2]?.type).toBe('tool-call')
-      expect(assistantMsg?.parts[3]?.type).toBe('tool-result')
-      expect(assistantMsg?.parts[4]?.type).toBe('text')
-
-      if (assistantMsg?.parts[0]?.type === 'text') {
-        expect(assistantMsg.parts[0].content).toBe('Hello world')
-      }
-      if (assistantMsg?.parts[1]?.type === 'thinking') {
-        expect(assistantMsg.parts[1].content).toBe('Let me think about this')
-      }
-      // When content chunk comes after tool calls, content field includes full accumulated text
-      // Since it's a new segment starting empty, it uses the full content
-      if (assistantMsg?.parts[4]?.type === 'text') {
-        expect(assistantMsg.parts[4].content).toBe('Hello worldDone!')
-      }
-    })
-
-    it('should handle complex approval flow with multiple tool calls', async () => {
-      const handlers: StreamProcessorHandlers = {
-        onToolInputAvailable: vi.fn(),
-        onApprovalRequested: vi.fn(),
-        onToolResultStateChange: vi.fn(),
-      }
-      const events: StreamProcessorEvents = {
-        onToolCall: vi.fn(),
-        onApprovalRequest: vi.fn(),
-        onMessagesChange: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-        events,
-      })
-
-      processor.startAssistantMessage()
-
-      // First tool input available
-      processor.processChunk({
-        type: 'tool-input-available',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        toolName: 'deleteFile',
-        input: { path: '/tmp/file1' },
-      })
-
-      // First tool call
-      processor.processChunk({
-        type: 'tool_call',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCall: {
-          id: 'call-1',
-          type: 'function',
-          function: { name: 'deleteFile', arguments: '{"path":"/tmp/file1"}' },
-        },
-        index: 0,
-      })
-
-      // First approval request
-      processor.processChunk({
-        type: 'approval-requested',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        toolName: 'deleteFile',
-        input: { path: '/tmp/file1' },
-        approval: {
-          id: 'approval-1',
-          needsApproval: true,
-        },
-      })
-
-      // Second tool input available
-      processor.processChunk({
-        type: 'tool-input-available',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-2',
-        toolName: 'deleteFile',
-        input: { path: '/tmp/file2' },
-      })
-
-      // Second tool call
-      processor.processChunk({
-        type: 'tool_call',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCall: {
-          id: 'call-2',
-          type: 'function',
-          function: { name: 'deleteFile', arguments: '{"path":"/tmp/file2"}' },
-        },
-        index: 1,
-      })
-
-      // Second approval request
-      processor.processChunk({
-        type: 'approval-requested',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-2',
-        toolName: 'deleteFile',
-        input: { path: '/tmp/file2' },
-        approval: {
-          id: 'approval-2',
-          needsApproval: true,
-        },
-      })
-
-      // First tool result
-      processor.processChunk({
-        type: 'tool_result',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-1',
-        content: '{"success":true}',
-      })
-
-      // Second tool result
-      processor.processChunk({
-        type: 'tool_result',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCallId: 'call-2',
-        content: '{"success":true}',
-      })
-
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-
-      // Should have 2 tool calls and 2 tool results
-      const toolCallParts = assistantMsg?.parts.filter(
-        (p) => p.type === 'tool-call',
-      )
-      const toolResultParts = assistantMsg?.parts.filter(
-        (p) => p.type === 'tool-result',
-      )
-
-      expect(toolCallParts).toHaveLength(2)
-      expect(toolResultParts).toHaveLength(2)
-
-      expect((toolCallParts?.[0] as any)?.id).toBe('call-1')
-      expect((toolCallParts?.[1] as any)?.id).toBe('call-2')
-      expect((toolResultParts?.[0] as any)?.toolCallId).toBe('call-1')
-      expect((toolResultParts?.[1] as any)?.toolCallId).toBe('call-2')
-
-      expect(handlers.onToolInputAvailable).toHaveBeenCalledTimes(2)
-      expect(handlers.onApprovalRequested).toHaveBeenCalledTimes(2)
-      expect(handlers.onToolResultStateChange).toHaveBeenCalledTimes(2)
-    })
-  })
-})
diff --git a/packages/typescript/ai/tests/stream-processor-replay.test.ts b/packages/typescript/ai/tests/stream-processor-replay.test.ts
deleted file mode 100644
index 11ca7c38..00000000
--- a/packages/typescript/ai/tests/stream-processor-replay.test.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { readFile } from 'fs/promises'
-import { join } from 'path'
-import { StreamProcessor } from '../src/activities/chat/stream'
-import type { ChunkRecording } from '../src/activities/chat/stream/types'
-
-async function loadFixture(name: string): Promise<ChunkRecording> {
-  const fixturePath = join(__dirname, 'fixtures', `${name}.json`)
-  const content = await readFile(fixturePath, 'utf-8')
-  return JSON.parse(content)
-}
-
-describe('StreamProcessor - Replay from Fixtures', () => {
-  it('should replay text-simple.json correctly', async () => {
-    const recording = await loadFixture('text-simple')
-    const result = await StreamProcessor.replay(recording)
-
-    expect(result.content).toBe('Hello world!')
-    expect(result.finishReason).toBe('stop')
-    expect(result.toolCalls).toBeUndefined()
-  })
-
-  it('should replay tool-call-parallel.json correctly', async () => {
-    const recording = await loadFixture('tool-call-parallel')
-    const result = await StreamProcessor.replay(recording)
-
-    expect(result.content).toBe('')
-    expect(result.toolCalls).toHaveLength(2)
-    expect(result.toolCalls?.[0]?.function.name).toBe('getWeather')
-    expect(result.toolCalls?.[0]?.function.arguments).toBe(
-      '{"location":"Paris"}',
-    )
-    expect(result.toolCalls?.[1]?.function.name).toBe('getTime')
-    expect(result.toolCalls?.[1]?.function.arguments).toBe('{"city":"Tokyo"}')
-    expect(result.finishReason).toBe('tool_calls')
-  })
-
-  it('should match expected result from recording', async () => {
-    const recording = await loadFixture('text-simple')
-    const result = await StreamProcessor.replay(recording)
-
-    // Verify result matches the expected result in the recording
-    expect(result.content).toBe(recording.result?.content)
-    expect(result.finishReason).toBe(recording.result?.finishReason)
-  })
-})
diff --git a/packages/typescript/ai/tests/stream-processor.test.ts b/packages/typescript/ai/tests/stream-processor.test.ts
deleted file mode 100644
index 61d97caa..00000000
--- a/packages/typescript/ai/tests/stream-processor.test.ts
+++ /dev/null
@@ -1,784 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import {
-  ImmediateStrategy,
-  PunctuationStrategy,
-  StreamProcessor,
-} from '../src/activities/chat/stream'
-import type { StreamProcessorHandlers } from '../src/activities/chat/stream'
-import type { StreamChunk, UIMessage } from '../src/types'
-
-// Mock stream generator helper
-async function* createMockStream(
-  chunks: Array<StreamChunk>,
-): AsyncGenerator<StreamChunk> {
-  for (const chunk of chunks) {
-    yield chunk
-  }
-}
-
-describe('StreamProcessor (Unified)', () => {
-  describe('Text Streaming', () => {
-    it('should accumulate text content from delta', async () => {
-      const handlers: StreamProcessorHandlers = {
-        onTextUpdate: vi.fn(),
-        onStreamEnd: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        chunkStrategy: new ImmediateStrategy(),
-        handlers,
-      })
-
-      const stream = createMockStream([
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: 'Hello',
-          content: 'Hello',
-          role: 'assistant',
-        },
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: ' world',
-          content: 'Hello world',
-          role: 'assistant',
-        },
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: '!',
-          content: 'Hello world!',
-          role: 'assistant',
-        },
-      ])
-
-      const result = await processor.process(stream)
-
-      expect(result.content).toBe('Hello world!')
-      expect(handlers.onTextUpdate).toHaveBeenCalledTimes(3)
-      expect(handlers.onTextUpdate).toHaveBeenNthCalledWith(1, 'Hello')
-      expect(handlers.onTextUpdate).toHaveBeenNthCalledWith(2, 'Hello world')
-      expect(handlers.onTextUpdate).toHaveBeenNthCalledWith(3, 'Hello world!')
-    })
-
-    it('should accumulate delta-only chunks', async () => {
-      const handlers: StreamProcessorHandlers = {
-        onTextUpdate: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-      })
-
-      const stream = createMockStream([
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: 'Hello',
-          content: 'Hello',
-          role: 'assistant',
-        },
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: ' world',
-          content: 'Hello world',
-          role: 'assistant',
-        },
-      ])
-
-      const result = await processor.process(stream)
-
-      expect(result.content).toBe('Hello world')
-      expect(handlers.onTextUpdate).toHaveBeenCalledWith('Hello')
-      expect(handlers.onTextUpdate).toHaveBeenCalledWith('Hello world')
-    })
-
-    it('should respect PunctuationStrategy', async () => {
-      const handlers: StreamProcessorHandlers = {
-        onTextUpdate: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        chunkStrategy: new PunctuationStrategy(),
-        handlers,
-      })
-
-      const stream = createMockStream([
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: 'Hello',
-          content: 'Hello',
-          role: 'assistant',
-        },
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: ' world',
-          content: 'Hello world',
-          role: 'assistant',
-        },
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: '!',
-          content: 'Hello world!',
-          role: 'assistant',
-        },
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: ' How',
-          content: 'Hello world! How',
-          role: 'assistant',
-        },
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: ' are',
-          content: 'Hello world! How are',
-          role: 'assistant',
-        },
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: ' you?',
-          content: 'Hello world! How are you?',
-          role: 'assistant',
-        },
-      ])
-
-      await processor.process(stream)
-
-      // Should only emit on punctuation (! and ?)
-      expect(handlers.onTextUpdate).toHaveBeenCalledTimes(2)
-      expect(handlers.onTextUpdate).toHaveBeenNthCalledWith(1, 'Hello world!')
-      expect(handlers.onTextUpdate).toHaveBeenNthCalledWith(
-        2,
-        'Hello world! How are you?',
-      )
-    })
-  })
-
-  describe('Single Tool Call', () => {
-    it('should track a single tool call', async () => {
-      const handlers: StreamProcessorHandlers = {
-        onToolCallStart: vi.fn(),
-        onToolCallDelta: vi.fn(),
-        onToolCallComplete: vi.fn(),
-        onStreamEnd: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-      })
-
-      const stream = createMockStream([
-        {
-          type: 'tool_call',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          toolCall: {
-            id: 'call_1',
-            type: 'function',
-            function: { name: 'getWeather', arguments: '{"lo' },
-          },
-          index: 0,
-        },
-        {
-          type: 'tool_call',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          toolCall: {
-            id: 'call_1',
-            type: 'function',
-            function: { name: 'getWeather', arguments: 'cation":' },
-          },
-          index: 0,
-        },
-        {
-          type: 'tool_call',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          toolCall: {
-            id: 'call_1',
-            type: 'function',
-            function: { name: 'getWeather', arguments: ' "Paris"}' },
-          },
-          index: 0,
-        },
-      ])
-
-      const result = await processor.process(stream)
-
-      // Verify start event
-      expect(handlers.onToolCallStart).toHaveBeenCalledTimes(1)
-      expect(handlers.onToolCallStart).toHaveBeenCalledWith(
-        0,
-        'call_1',
-        'getWeather',
-      )
-
-      // Verify delta events
-      expect(handlers.onToolCallDelta).toHaveBeenCalledTimes(3)
-
-      // Verify completion (triggered by stream end)
-      expect(handlers.onToolCallComplete).toHaveBeenCalledTimes(1)
-      expect(handlers.onToolCallComplete).toHaveBeenCalledWith(
-        0,
-        'call_1',
-        'getWeather',
-        '{"location": "Paris"}',
-      )
-
-      // Verify result
-      expect(result.toolCalls).toHaveLength(1)
-      expect(result.toolCalls![0]).toEqual({
-        id: 'call_1',
-        type: 'function',
-        function: {
-          name: 'getWeather',
-          arguments: '{"location": "Paris"}',
-        },
-      })
-    })
-  })
-
-  describe('Recording and Replay', () => {
-    it('should record chunks when recording is enabled', async () => {
-      const processor = new StreamProcessor({ recording: true })
-
-      const chunks: Array<StreamChunk> = [
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: 'Hello',
-          content: 'Hello',
-          role: 'assistant',
-        },
-        {
-          type: 'done',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          finishReason: 'stop',
-        },
-      ]
-
-      await processor.process(createMockStream(chunks))
-
-      const recording = processor.getRecording()
-      expect(recording).toBeDefined()
-      expect(recording?.chunks).toHaveLength(2)
-      expect(recording?.chunks[0]?.chunk.type).toBe('content')
-      expect(recording?.result?.content).toBe('Hello')
-    })
-
-    it('should replay a recording and produce the same result', async () => {
-      // First, create a recording
-      const processor1 = new StreamProcessor({ recording: true })
-      const chunks: Array<StreamChunk> = [
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: 'Test message',
-          content: 'Test message',
-          role: 'assistant',
-        },
-        {
-          type: 'tool_call',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          toolCall: {
-            id: 'call_1',
-            type: 'function',
-            function: { name: 'testTool', arguments: '{"arg":"value"}' },
-          },
-          index: 0,
-        },
-        {
-          type: 'done',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          finishReason: 'tool_calls',
-        },
-      ]
-
-      const result1 = await processor1.process(createMockStream(chunks))
-      const recording = processor1.getRecording()!
-
-      // Now replay the recording
-      const result2 = await StreamProcessor.replay(recording)
-
-      // Results should match
-      expect(result2.content).toBe(result1.content)
-      expect(result2.toolCalls).toEqual(result1.toolCalls)
-      expect(result2.finishReason).toBe(result1.finishReason)
-    })
-  })
-
-  describe('Mixed: Tool Calls + Text', () => {
-    it('should complete tool calls when text arrives', async () => {
-      const handlers: StreamProcessorHandlers = {
-        onToolCallStart: vi.fn(),
-        onToolCallComplete: vi.fn(),
-        onTextUpdate: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-      })
-
-      const stream = createMockStream([
-        {
-          type: 'tool_call',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          toolCall: {
-            id: 'call_1',
-            type: 'function',
-            function: { name: 'getWeather', arguments: '{"location":"Paris"}' },
-          },
-          index: 0,
-        },
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: 'The weather in Paris is',
-          content: 'The weather in Paris is',
-          role: 'assistant',
-        },
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: ' sunny',
-          content: 'The weather in Paris is sunny',
-          role: 'assistant',
-        },
-      ])
-
-      const result = await processor.process(stream)
-
-      // Tool call should complete when text arrives
-      expect(handlers.onToolCallComplete).toHaveBeenCalledWith(
-        0,
-        'call_1',
-        'getWeather',
-        '{"location":"Paris"}',
-      )
-
-      // Text should accumulate
-      expect(result.content).toBe('The weather in Paris is sunny')
-      expect(result.toolCalls).toHaveLength(1)
-    })
-
-    it('should emit separate text segments when text appears before and after tool calls', async () => {
-      const textUpdates: Array<string> = []
-      const handlers: StreamProcessorHandlers = {
-        onToolCallStart: vi.fn(),
-        onToolCallComplete: vi.fn(),
-        onTextUpdate: (text) => textUpdates.push(text),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-      })
-
-      // Simulates the Anthropic-style pattern: Text1 -> ToolCall -> Text2
-      // Each text segment has its own accumulated content field
-      const stream = createMockStream([
-        // First text segment
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: 'Let me check the guitars.',
-          content: 'Let me check the guitars.',
-          role: 'assistant',
-        },
-        // Tool call
-        {
-          type: 'tool_call',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          toolCall: {
-            id: 'call_1',
-            type: 'function',
-            function: { name: 'getGuitars', arguments: '{}' },
-          },
-          index: 0,
-        },
-        // Second text segment - note the content field starts fresh, not including first segment
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: 'Based on the results,',
-          content: 'Based on the results,', // Fresh start, not "Let me check the guitars.Based on..."
-          role: 'assistant',
-        },
-        {
-          type: 'content',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: ' I recommend the Taylor.',
-          content: 'Based on the results, I recommend the Taylor.',
-          role: 'assistant',
-        },
-      ])
-
-      const result = await processor.process(stream)
-
-      // Should have both text segments combined in result.content
-      expect(result.content).toBe(
-        'Let me check the guitars.Based on the results, I recommend the Taylor.',
-      )
-
-      // Should have emitted text updates for both segments separately
-      // The first segment should be emitted completely
-      expect(textUpdates).toContain('Let me check the guitars.')
-      // The second segment is emitted separately (per-segment behavior)
-      expect(textUpdates[textUpdates.length - 1]).toBe(
-        'Based on the results, I recommend the Taylor.',
-      )
-
-      expect(result.toolCalls).toHaveLength(1)
-    })
-  })
-
-  describe('Thinking Chunks', () => {
-    it('should accumulate thinking content', async () => {
-      const handlers: StreamProcessorHandlers = {
-        onThinkingUpdate: vi.fn(),
-      }
-
-      const processor = new StreamProcessor({
-        handlers,
-      })
-
-      const stream = createMockStream([
-        {
-          type: 'thinking',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: 'Let me think...',
-          content: 'Let me think...',
-        },
-        {
-          type: 'thinking',
-          id: 'msg-1',
-          model: 'test',
-          timestamp: Date.now(),
-          delta: ' about this',
-          content: 'Let me think... about this',
-        },
-      ])
-
-      const result = await processor.process(stream)
-
-      expect(result.thinking).toBe('Let me think... about this')
-      expect(handlers.onThinkingUpdate).toHaveBeenCalledTimes(2)
-    })
-  })
-
-  describe('Message Management', () => {
-    it('should initialize with empty messages', () => {
-      const processor = new StreamProcessor({})
-      expect(processor.getMessages()).toEqual([])
-    })
-
-    it('should initialize with provided messages', () => {
-      const initialMessages: Array<UIMessage> = [
-        {
-          id: 'msg-1',
-          role: 'user',
-          parts: [{ type: 'text', content: 'Hello' }],
-        },
-      ]
-
-      const processor = new StreamProcessor({
-        initialMessages,
-      })
-
-      expect(processor.getMessages()).toHaveLength(1)
-      expect(processor.getMessages()[0]?.role).toBe('user')
-    })
-
-    it('should add user messages', () => {
-      const processor = new StreamProcessor({})
-
-      const userMessage = processor.addUserMessage('Hello, AI!')
-
-      expect(userMessage.role).toBe('user')
-      expect(userMessage.parts).toHaveLength(1)
-      expect(userMessage.parts[0]).toEqual({
-        type: 'text',
-        content: 'Hello, AI!',
-      })
-      expect(processor.getMessages()).toHaveLength(1)
-    })
-
-    it('should emit onMessagesChange when adding user message', () => {
-      const onMessagesChange = vi.fn()
-      const processor = new StreamProcessor({
-        events: { onMessagesChange },
-      })
-
-      processor.addUserMessage('Hello')
-
-      expect(onMessagesChange).toHaveBeenCalledTimes(1)
-      expect(onMessagesChange).toHaveBeenCalledWith(
-        expect.arrayContaining([expect.objectContaining({ role: 'user' })]),
-      )
-    })
-
-    it('should start and track assistant message during streaming', async () => {
-      const onMessagesChange = vi.fn()
-      const onStreamStart = vi.fn()
-      const onStreamEnd = vi.fn()
-
-      const processor = new StreamProcessor({
-        events: {
-          onMessagesChange,
-          onStreamStart,
-          onStreamEnd,
-        },
-      })
-
-      // Add a user message first
-      processor.addUserMessage('What is the weather?')
-      onMessagesChange.mockClear()
-
-      // Start streaming
-      const messageId = processor.startAssistantMessage()
-      expect(messageId).toBeDefined()
-      expect(onStreamStart).toHaveBeenCalledTimes(1)
-
-      // Messages should include the empty assistant message
-      const messages = processor.getMessages()
-      expect(messages).toHaveLength(2)
-      expect(messages[1]?.role).toBe('assistant')
-      expect(messages[1]?.parts).toEqual([])
-
-      // Process a chunk
-      processor.processChunk({
-        type: 'content',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        delta: 'The weather is sunny.',
-        content: 'The weather is sunny.',
-        role: 'assistant',
-      })
-
-      // Finalize
-      processor.finalizeStream()
-      expect(onStreamEnd).toHaveBeenCalledTimes(1)
-
-      // Final messages should have text content
-      const finalMessages = processor.getMessages()
-      expect(finalMessages[1]?.parts).toContainEqual({
-        type: 'text',
-        content: 'The weather is sunny.',
-      })
-    })
-
-    it('should convert messages to ModelMessages', () => {
-      const processor = new StreamProcessor({})
-
-      processor.addUserMessage('Hello')
-
-      const modelMessages = processor.toModelMessages()
-      expect(modelMessages).toHaveLength(1)
-      expect(modelMessages[0]).toEqual({
-        role: 'user',
-        content: 'Hello',
-      })
-    })
-
-    it('should add tool results', async () => {
-      const onMessagesChange = vi.fn()
-      const processor = new StreamProcessor({
-        events: { onMessagesChange },
-      })
-
-      // Add user message and start assistant message
-      processor.addUserMessage('Get the weather')
-      processor.startAssistantMessage()
-
-      // Process a tool call chunk
-      processor.processChunk({
-        type: 'tool_call',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCall: {
-          id: 'call_1',
-          type: 'function',
-          function: { name: 'getWeather', arguments: '{"location":"Paris"}' },
-        },
-        index: 0,
-      })
-
-      processor.finalizeStream()
-      onMessagesChange.mockClear()
-
-      // Add tool result
-      processor.addToolResult('call_1', {
-        temperature: 20,
-        conditions: 'sunny',
-      })
-
-      expect(onMessagesChange).toHaveBeenCalled()
-
-      // Check that the tool call has output and tool result part exists
-      const messages = processor.getMessages()
-      const assistantMsg = messages.find((m) => m.role === 'assistant')
-      expect(assistantMsg?.parts).toContainEqual(
-        expect.objectContaining({
-          type: 'tool-call',
-          id: 'call_1',
-          output: { temperature: 20, conditions: 'sunny' },
-        }),
-      )
-      expect(assistantMsg?.parts).toContainEqual(
-        expect.objectContaining({
-          type: 'tool-result',
-          toolCallId: 'call_1',
-          state: 'complete',
-        }),
-      )
-    })
-
-    it('should check if all tools are complete', async () => {
-      const processor = new StreamProcessor({})
-
-      processor.addUserMessage('Get the weather')
-      processor.startAssistantMessage()
-
-      // Process a tool call
-      processor.processChunk({
-        type: 'tool_call',
-        id: 'msg-1',
-        model: 'test',
-        timestamp: Date.now(),
-        toolCall: {
-          id: 'call_1',
-          type: 'function',
-          function: { name: 'getWeather', arguments: '{}' },
-        },
-        index: 0,
-      })
-      processor.finalizeStream()
-
-      // Tool call is complete but no result yet
-      expect(processor.areAllToolsComplete()).toBe(false)
-
-      // Add tool result
-      processor.addToolResult('call_1', { result: 'sunny' })
-
-      // Now it should be complete
-      expect(processor.areAllToolsComplete()).toBe(true)
-    })
-
-    it('should clear messages', () => {
-      const onMessagesChange = vi.fn()
-      const processor = new StreamProcessor({
-        events: { onMessagesChange },
-      })
-
-      processor.addUserMessage('Hello')
-      processor.addUserMessage('World')
-      expect(processor.getMessages()).toHaveLength(2)
-
-      onMessagesChange.mockClear()
-      processor.clearMessages()
-
-      expect(processor.getMessages()).toHaveLength(0)
-      expect(onMessagesChange).toHaveBeenCalledWith([])
-    })
-
-    it('should remove messages after index', () => {
-      const processor = new StreamProcessor({})
-
-      processor.addUserMessage('Message 1')
-      processor.addUserMessage('Message 2')
-      processor.addUserMessage('Message 3')
-      expect(processor.getMessages()).toHaveLength(3)
-
-      processor.removeMessagesAfter(0)
-
-      expect(processor.getMessages()).toHaveLength(1)
-      expect(processor.getMessages()[0]?.parts[0]).toEqual({
-        type: 'text',
-        content: 'Message 1',
-      })
-    })
-
-    it('should set messages manually', () => {
-      const processor = new StreamProcessor({})
-
-      const newMessages: Array<UIMessage> = [
-        {
-          id: 'msg-1',
-          role: 'user',
-          parts: [{ type: 'text', content: 'Test' }],
-        },
-        {
-          id: 'msg-2',
-          role: 'assistant',
-          parts: [{ type: 'text', content: 'Response' }],
-        },
-      ]
-
-      processor.setMessages(newMessages)
-
-      expect(processor.getMessages()).toHaveLength(2)
-      expect(processor.getMessages()[0]?.role).toBe('user')
-      expect(processor.getMessages()[1]?.role).toBe('assistant')
-    })
-  })
-})
diff --git a/packages/typescript/ai/tests/stream-to-response.test.ts b/packages/typescript/ai/tests/stream-to-response.test.ts
index 98b0db43..06f86450 100644
--- a/packages/typescript/ai/tests/stream-to-response.test.ts
+++ b/packages/typescript/ai/tests/stream-to-response.test.ts
@@ -37,22 +37,20 @@ describe('toServerSentEventsStream', () => {
   it('should convert chunks to SSE format', async () => {
     const chunks: Array<StreamChunk> = [
       {
-        type: 'content',
-        id: 'msg-1',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         model: 'test',
         timestamp: Date.now(),
         delta: 'Hello',
         content: 'Hello',
-        role: 'assistant',
       },
       {
-        type: 'content',
-        id: 'msg-1',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         model: 'test',
         timestamp: Date.now(),
         delta: ' world',
         content: 'Hello world',
-        role: 'assistant',
       },
     ]
 
@@ -61,7 +59,7 @@ describe('toServerSentEventsStream', () => {
     const output = await readStream(sseStream)
 
     expect(output).toContain('data: ')
-    expect(output).toContain('"type":"content"')
+    expect(output).toContain('"type":"TEXT_MESSAGE_CONTENT"')
     expect(output).toContain('\n\n')
     expect(output).toContain('data: [DONE]\n\n')
   })
@@ -69,13 +67,12 @@ describe('toServerSentEventsStream', () => {
   it('should format each chunk with data: prefix', async () => {
     const chunks: Array<StreamChunk> = [
       {
-        type: 'content',
-        id: 'msg-1',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         model: 'test',
         timestamp: Date.now(),
         delta: 'Test',
         content: 'Test',
-        role: 'assistant',
       },
     ]
 
@@ -91,13 +88,12 @@ describe('toServerSentEventsStream', () => {
   it('should end with [DONE] marker', async () => {
     const chunks: Array<StreamChunk> = [
       {
-        type: 'content',
-        id: 'msg-1',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         model: 'test',
         timestamp: Date.now(),
         delta: 'Test',
         content: 'Test',
-        role: 'assistant',
       },
     ]
 
@@ -112,18 +108,14 @@ describe('toServerSentEventsStream', () => {
     expect(afterDone).toBe('data: [DONE]\n\n')
   })
 
-  it('should handle tool call chunks', async () => {
+  it('should handle tool call events', async () => {
     const chunks: Array<StreamChunk> = [
       {
-        type: 'tool_call',
-        id: 'msg-1',
+        type: 'TOOL_CALL_START',
+        toolCallId: 'call-1',
+        toolName: 'getWeather',
         model: 'test',
         timestamp: Date.now(),
-        toolCall: {
-          id: 'call-1',
-          type: 'function',
-          function: { name: 'getWeather', arguments: '{}' },
-        },
         index: 0,
       },
     ]
@@ -132,16 +124,16 @@ describe('toServerSentEventsStream', () => {
     const sseStream = toServerSentEventsStream(stream)
     const output = await readStream(sseStream)
 
-    expect(output).toContain('"type":"tool_call"')
-    expect(output).toContain('"name":"getWeather"')
+    expect(output).toContain('"type":"TOOL_CALL_START"')
+    expect(output).toContain('"toolName":"getWeather"')
     expect(output).toContain('data: [DONE]\n\n')
   })
 
-  it('should handle done chunks', async () => {
+  it('should handle RUN_FINISHED events', async () => {
     const chunks: Array<StreamChunk> = [
       {
-        type: 'done',
-        id: 'msg-1',
+        type: 'RUN_FINISHED',
+        runId: 'run-1',
         model: 'test',
         timestamp: Date.now(),
         finishReason: 'stop',
@@ -152,16 +144,16 @@ describe('toServerSentEventsStream', () => {
     const sseStream = toServerSentEventsStream(stream)
     const output = await readStream(sseStream)
 
-    expect(output).toContain('"type":"done"')
+    expect(output).toContain('"type":"RUN_FINISHED"')
     expect(output).toContain('"finishReason":"stop"')
     expect(output).toContain('data: [DONE]\n\n')
   })
 
-  it('should handle error chunks', async () => {
+  it('should handle RUN_ERROR events', async () => {
     const chunks: Array<StreamChunk> = [
       {
-        type: 'error',
-        id: 'msg-1',
+        type: 'RUN_ERROR',
+        runId: 'run-1',
         model: 'test',
         timestamp: Date.now(),
         error: { message: 'Test error' },
@@ -172,7 +164,7 @@ describe('toServerSentEventsStream', () => {
     const sseStream = toServerSentEventsStream(stream)
     const output = await readStream(sseStream)
 
-    expect(output).toContain('"type":"error"')
+    expect(output).toContain('"type":"RUN_ERROR"')
     expect(output).toContain('data: [DONE]\n\n')
   })
 
@@ -188,13 +180,12 @@ describe('toServerSentEventsStream', () => {
     const abortController = new AbortController()
     const chunks: Array<StreamChunk> = [
       {
-        type: 'content',
-        id: 'msg-1',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         model: 'test',
         timestamp: Date.now(),
         delta: 'Test',
         content: 'Test',
-        role: 'assistant',
       },
     ]
 
@@ -207,19 +198,18 @@ describe('toServerSentEventsStream', () => {
     const output = await readStream(sseStream)
 
     // Should not have processed chunks after abort
-    expect(output).not.toContain('"type":"content"')
+    expect(output).not.toContain('"type":"TEXT_MESSAGE_CONTENT"')
   })
 
   it('should handle stream errors and send error chunk', async () => {
     async function* errorStream(): AsyncGenerator<StreamChunk> {
       yield {
-        type: 'content',
-        id: 'msg-1',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         model: 'test',
         timestamp: Date.now(),
         delta: 'Test',
         content: 'Test',
-        role: 'assistant',
       }
       throw new Error('Stream error')
     }
@@ -227,7 +217,7 @@ describe('toServerSentEventsStream', () => {
     const sseStream = toServerSentEventsStream(errorStream())
     const output = await readStream(sseStream)
 
-    expect(output).toContain('"type":"error"')
+    expect(output).toContain('"type":"RUN_ERROR"')
     expect(output).toContain('"message":"Stream error"')
   })
 
@@ -243,7 +233,7 @@ describe('toServerSentEventsStream', () => {
     const output = await readStream(sseStream)
 
     // Should close without error chunk
-    expect(output).not.toContain('"type":"error"')
+    expect(output).not.toContain('"type":"RUN_ERROR"')
   })
 
   it('should handle cancel and abort underlying stream', async () => {
@@ -252,13 +242,12 @@ describe('toServerSentEventsStream', () => {
 
     const chunks: Array<StreamChunk> = [
       {
-        type: 'content',
-        id: 'msg-1',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         model: 'test',
         timestamp: Date.now(),
         delta: 'Test',
         content: 'Test',
-        role: 'assistant',
       },
     ]
 
@@ -274,29 +263,24 @@ describe('toServerSentEventsStream', () => {
   it('should handle multiple chunks correctly', async () => {
     const chunks: Array<StreamChunk> = [
       {
-        type: 'content',
-        id: 'msg-1',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         model: 'test',
         timestamp: Date.now(),
         delta: 'Hello',
         content: 'Hello',
-        role: 'assistant',
       },
       {
-        type: 'tool_call',
-        id: 'msg-1',
+        type: 'TOOL_CALL_START',
+        toolCallId: 'call-1',
+        toolName: 'getWeather',
         model: 'test',
         timestamp: Date.now(),
-        toolCall: {
-          id: 'call-1',
-          type: 'function',
-          function: { name: 'getWeather', arguments: '{}' },
-        },
         index: 0,
       },
       {
-        type: 'done',
-        id: 'msg-1',
+        type: 'RUN_FINISHED',
+        runId: 'run-1',
         model: 'test',
         timestamp: Date.now(),
         finishReason: 'tool_calls',
@@ -319,13 +303,12 @@ describe('toServerSentEventsResponse', () => {
   it('should create Response with SSE headers', async () => {
     const chunks: Array<StreamChunk> = [
       {
-        type: 'content',
-        id: 'msg-1',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         model: 'test',
         timestamp: Date.now(),
         delta: 'Test',
         content: 'Test',
-        role: 'assistant',
       },
     ]
 
@@ -370,13 +353,12 @@ describe('toServerSentEventsResponse', () => {
     const abortController = new AbortController()
     const chunks: Array<StreamChunk> = [
       {
-        type: 'content',
-        id: 'msg-1',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         model: 'test',
         timestamp: Date.now(),
         delta: 'Test',
         content: 'Test',
-        role: 'assistant',
       },
     ]
 
@@ -411,22 +393,20 @@ describe('toServerSentEventsResponse', () => {
   it('should stream chunks correctly through Response', async () => {
     const chunks: Array<StreamChunk> = [
       {
-        type: 'content',
-        id: 'msg-1',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         model: 'test',
         timestamp: Date.now(),
         delta: 'Hello',
         content: 'Hello',
-        role: 'assistant',
       },
       {
-        type: 'content',
-        id: 'msg-1',
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
         model: 'test',
         timestamp: Date.now(),
         delta: ' world',
         content: 'Hello world',
-        role: 'assistant',
       },
     ]
 
@@ -440,7 +420,7 @@ describe('toServerSentEventsResponse', () => {
     const output = await readStream(response.body)
 
     expect(output).toContain('data: ')
-    expect(output).toContain('"type":"content"')
+    expect(output).toContain('"type":"TEXT_MESSAGE_CONTENT"')
     expect(output).toContain('"delta":"Hello"')
     expect(output).toContain('"delta":" world"')
     expect(output).toContain('data: [DONE]\n\n')
@@ -464,3 +444,405 @@ describe('toServerSentEventsResponse', () => {
     expect(response.headers.get('Content-Type')).toBe('text/event-stream')
   })
 })
+
+/**
+ * SSE Round-Trip Tests
+ *
+ * These tests verify that all AG-UI event types survive the SSE encoding/decoding cycle.
+ * This simulates the full server → client flow.
+ */
+describe('SSE Round-Trip (Encode → Decode)', () => {
+  /**
+   * Helper to parse SSE stream back into chunks
+   */
+  async function parseSSEStream(
+    sseStream: ReadableStream<Uint8Array>,
+  ): Promise<Array<StreamChunk>> {
+    const reader = sseStream.getReader()
+    const decoder = new TextDecoder()
+    const chunks: Array<StreamChunk> = []
+    let buffer = ''
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+        const lines = buffer.split('\n\n')
+        buffer = lines.pop() || ''
+
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6)
+            if (data === '[DONE]') continue
+            try {
+              chunks.push(JSON.parse(data))
+            } catch {
+              // Skip invalid JSON
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock()
+    }
+
+    return chunks
+  }
+
+  it('should preserve TEXT_MESSAGE_CONTENT events', async () => {
+    const originalChunks: Array<StreamChunk> = [
+      {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
+        model: 'test-model',
+        timestamp: 1234567890,
+        delta: 'Hello',
+        content: 'Hello',
+      },
+      {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
+        model: 'test-model',
+        timestamp: 1234567891,
+        delta: ' world',
+        content: 'Hello world',
+      },
+    ]
+
+    const sseStream = toServerSentEventsStream(createMockStream(originalChunks))
+    const parsedChunks = await parseSSEStream(sseStream)
+
+    expect(parsedChunks.length).toBe(2)
+
+    for (let i = 0; i < originalChunks.length; i++) {
+      const original = originalChunks[i]
+      const parsed = parsedChunks[i]
+
+      expect(parsed?.type).toBe(original?.type)
+      expect((parsed as any)?.messageId).toBe((original as any)?.messageId)
+      expect((parsed as any)?.delta).toBe((original as any)?.delta)
+      expect((parsed as any)?.content).toBe((original as any)?.content)
+    }
+  })
+
+  it('should preserve TOOL_CALL_* events', async () => {
+    const originalChunks: Array<StreamChunk> = [
+      {
+        type: 'TOOL_CALL_START',
+        toolCallId: 'tc-1',
+        toolName: 'get_weather',
+        model: 'test',
+        timestamp: Date.now(),
+        index: 0,
+      },
+      {
+        type: 'TOOL_CALL_ARGS',
+        toolCallId: 'tc-1',
+        model: 'test',
+        timestamp: Date.now(),
+        delta: '{"city":"NYC"}',
+      },
+      {
+        type: 'TOOL_CALL_END',
+        toolCallId: 'tc-1',
+        toolName: 'get_weather',
+        model: 'test',
+        timestamp: Date.now(),
+      },
+    ]
+
+    const sseStream = toServerSentEventsStream(createMockStream(originalChunks))
+    const parsedChunks = await parseSSEStream(sseStream)
+
+    expect(parsedChunks.length).toBe(3)
+
+    // Verify TOOL_CALL_START
+    expect(parsedChunks[0]?.type).toBe('TOOL_CALL_START')
+    expect((parsedChunks[0] as any)?.toolCallId).toBe('tc-1')
+    expect((parsedChunks[0] as any)?.toolName).toBe('get_weather')
+    expect((parsedChunks[0] as any)?.index).toBe(0)
+
+    // Verify TOOL_CALL_ARGS
+    expect(parsedChunks[1]?.type).toBe('TOOL_CALL_ARGS')
+    expect((parsedChunks[1] as any)?.toolCallId).toBe('tc-1')
+    expect((parsedChunks[1] as any)?.delta).toBe('{"city":"NYC"}')
+
+    // Verify TOOL_CALL_END
+    expect(parsedChunks[2]?.type).toBe('TOOL_CALL_END')
+    expect((parsedChunks[2] as any)?.toolCallId).toBe('tc-1')
+  })
+
+  it('should preserve RUN_* events', async () => {
+    const originalChunks: Array<StreamChunk> = [
+      {
+        type: 'RUN_STARTED',
+        runId: 'run-1',
+        model: 'test',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'RUN_FINISHED',
+        runId: 'run-1',
+        model: 'test',
+        timestamp: Date.now(),
+        finishReason: 'stop',
+      },
+    ]
+
+    const sseStream = toServerSentEventsStream(createMockStream(originalChunks))
+    const parsedChunks = await parseSSEStream(sseStream)
+
+    expect(parsedChunks.length).toBe(2)
+
+    expect(parsedChunks[0]?.type).toBe('RUN_STARTED')
+    expect((parsedChunks[0] as any)?.runId).toBe('run-1')
+
+    expect(parsedChunks[1]?.type).toBe('RUN_FINISHED')
+    expect((parsedChunks[1] as any)?.finishReason).toBe('stop')
+  })
+
+  it('should preserve RUN_ERROR events', async () => {
+    const originalChunks: Array<StreamChunk> = [
+      {
+        type: 'RUN_ERROR',
+        runId: 'run-1',
+        model: 'test',
+        timestamp: Date.now(),
+        error: { message: 'Something went wrong', code: 'TEST_ERROR' },
+      },
+    ]
+
+    const sseStream = toServerSentEventsStream(createMockStream(originalChunks))
+    const parsedChunks = await parseSSEStream(sseStream)
+
+    expect(parsedChunks.length).toBe(1)
+    expect(parsedChunks[0]?.type).toBe('RUN_ERROR')
+    expect((parsedChunks[0] as any)?.error?.message).toBe(
+      'Something went wrong',
+    )
+    expect((parsedChunks[0] as any)?.error?.code).toBe('TEST_ERROR')
+  })
+
+  it('should preserve STEP_FINISHED events (thinking)', async () => {
+    const originalChunks: Array<StreamChunk> = [
+      {
+        type: 'STEP_STARTED',
+        stepId: 'step-1',
+        model: 'test',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'STEP_FINISHED',
+        stepId: 'step-1',
+        model: 'test',
+        timestamp: Date.now(),
+        delta: 'Let me think...',
+        content: 'Let me think...',
+      },
+    ]
+
+    const sseStream = toServerSentEventsStream(createMockStream(originalChunks))
+    const parsedChunks = await parseSSEStream(sseStream)
+
+    expect(parsedChunks.length).toBe(2)
+
+    expect(parsedChunks[0]?.type).toBe('STEP_STARTED')
+    expect((parsedChunks[0] as any)?.stepId).toBe('step-1')
+
+    expect(parsedChunks[1]?.type).toBe('STEP_FINISHED')
+    expect((parsedChunks[1] as any)?.delta).toBe('Let me think...')
+  })
+
+  it('should preserve CUSTOM events', async () => {
+    const originalChunks: Array<StreamChunk> = [
+      {
+        type: 'CUSTOM',
+        model: 'test',
+        timestamp: Date.now(),
+        name: 'tool-input-available',
+        data: {
+          toolCallId: 'tc-1',
+          toolName: 'get_weather',
+          input: { city: 'NYC', units: 'fahrenheit' },
+        },
+      },
+      {
+        type: 'CUSTOM',
+        model: 'test',
+        timestamp: Date.now(),
+        name: 'approval-requested',
+        data: {
+          toolCallId: 'tc-2',
+          toolName: 'delete_file',
+          input: { path: '/tmp/file.txt' },
+          approval: { id: 'approval-1' },
+        },
+      },
+    ]
+
+    const sseStream = toServerSentEventsStream(createMockStream(originalChunks))
+    const parsedChunks = await parseSSEStream(sseStream)
+
+    expect(parsedChunks.length).toBe(2)
+
+    // Verify tool-input-available
+    expect(parsedChunks[0]?.type).toBe('CUSTOM')
+    expect((parsedChunks[0] as any)?.name).toBe('tool-input-available')
+    expect((parsedChunks[0] as any)?.data?.toolCallId).toBe('tc-1')
+    expect((parsedChunks[0] as any)?.data?.input?.city).toBe('NYC')
+
+    // Verify approval-requested
+    expect(parsedChunks[1]?.type).toBe('CUSTOM')
+    expect((parsedChunks[1] as any)?.name).toBe('approval-requested')
+    expect((parsedChunks[1] as any)?.data?.approval?.id).toBe('approval-1')
+  })
+
+  it('should preserve TEXT_MESSAGE_START/END events', async () => {
+    const originalChunks: Array<StreamChunk> = [
+      {
+        type: 'TEXT_MESSAGE_START',
+        messageId: 'msg-1',
+        model: 'test',
+        timestamp: Date.now(),
+        role: 'assistant',
+      },
+      {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
+        model: 'test',
+        timestamp: Date.now(),
+        delta: 'Hello',
+      },
+      {
+        type: 'TEXT_MESSAGE_END',
+        messageId: 'msg-1',
+        model: 'test',
+        timestamp: Date.now(),
+      },
+    ]
+
+    const sseStream = toServerSentEventsStream(createMockStream(originalChunks))
+    const parsedChunks = await parseSSEStream(sseStream)
+
+    expect(parsedChunks.length).toBe(3)
+    expect(parsedChunks[0]?.type).toBe('TEXT_MESSAGE_START')
+    expect(parsedChunks[1]?.type).toBe('TEXT_MESSAGE_CONTENT')
+    expect(parsedChunks[2]?.type).toBe('TEXT_MESSAGE_END')
+  })
+
+  it('should preserve complex mixed event sequence', async () => {
+    const originalChunks: Array<StreamChunk> = [
+      {
+        type: 'RUN_STARTED',
+        runId: 'run-1',
+        model: 'test',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'TEXT_MESSAGE_START',
+        messageId: 'msg-1',
+        model: 'test',
+        timestamp: Date.now(),
+        role: 'assistant',
+      },
+      {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
+        model: 'test',
+        timestamp: Date.now(),
+        delta: 'Let me help you.',
+      },
+      {
+        type: 'TEXT_MESSAGE_END',
+        messageId: 'msg-1',
+        model: 'test',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'TOOL_CALL_START',
+        toolCallId: 'tc-1',
+        toolName: 'search',
+        model: 'test',
+        timestamp: Date.now(),
+        index: 0,
+      },
+      {
+        type: 'TOOL_CALL_ARGS',
+        toolCallId: 'tc-1',
+        model: 'test',
+        timestamp: Date.now(),
+        delta: '{"query":"test"}',
+      },
+      {
+        type: 'TOOL_CALL_END',
+        toolCallId: 'tc-1',
+        toolName: 'search',
+        model: 'test',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'CUSTOM',
+        model: 'test',
+        timestamp: Date.now(),
+        name: 'tool-input-available',
+        data: {
+          toolCallId: 'tc-1',
+          toolName: 'search',
+          input: { query: 'test' },
+        },
+      },
+      {
+        type: 'RUN_FINISHED',
+        runId: 'run-1',
+        model: 'test',
+        timestamp: Date.now(),
+        finishReason: 'tool_calls',
+      },
+    ]
+
+    const sseStream = toServerSentEventsStream(createMockStream(originalChunks))
+    const parsedChunks = await parseSSEStream(sseStream)
+
+    expect(parsedChunks.length).toBe(9)
+
+    // Verify event types in order
+    const expectedTypes = [
+      'RUN_STARTED',
+      'TEXT_MESSAGE_START',
+      'TEXT_MESSAGE_CONTENT',
+      'TEXT_MESSAGE_END',
+      'TOOL_CALL_START',
+      'TOOL_CALL_ARGS',
+      'TOOL_CALL_END',
+      'CUSTOM',
+      'RUN_FINISHED',
+    ]
+
+    for (let i = 0; i < expectedTypes.length; i++) {
+      expect(parsedChunks[i]?.type).toBe(expectedTypes[i])
+    }
+  })
+
+  it('should preserve unicode and special characters', async () => {
+    const originalChunks: Array<StreamChunk> = [
+      {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'msg-1',
+        model: 'test',
+        timestamp: Date.now(),
+        delta: 'Hello 世界! 🌍 Special chars: <>&"\'\n\t',
+        content: 'Hello 世界! 🌍 Special chars: <>&"\'\n\t',
+      },
+    ]
+
+    const sseStream = toServerSentEventsStream(createMockStream(originalChunks))
+    const parsedChunks = await parseSSEStream(sseStream)
+
+    expect(parsedChunks.length).toBe(1)
+    expect((parsedChunks[0] as any)?.delta).toBe(
+      'Hello 世界! 🌍 Special chars: <>&"\'\n\t',
+    )
+  })
+})
diff --git a/packages/typescript/ai/tests/tool-call-manager.test.ts b/packages/typescript/ai/tests/tool-call-manager.test.ts
index af117f08..4b372abc 100644
--- a/packages/typescript/ai/tests/tool-call-manager.test.ts
+++ b/packages/typescript/ai/tests/tool-call-manager.test.ts
@@ -1,12 +1,12 @@
 import { describe, expect, it, vi } from 'vitest'
 import { z } from 'zod'
 import { ToolCallManager } from '../src/activities/chat/tools/tool-calls'
-import type { DoneStreamChunk, Tool } from '../src/types'
+import type { RunFinishedEvent, Tool } from '../src/types'
 
 describe('ToolCallManager', () => {
-  const mockDoneChunk: DoneStreamChunk = {
-    type: 'done',
-    id: 'test-id',
+  const mockFinishedEvent: RunFinishedEvent = {
+    type: 'RUN_FINISHED',
+    runId: 'test-run-id',
     model: 'gpt-4',
     timestamp: Date.now(),
     finishReason: 'tool_calls',
@@ -38,25 +38,29 @@ describe('ToolCallManager', () => {
     return { chunks, result: next.value }
   }
 
-  it('should accumulate tool call chunks', () => {
+  it('should accumulate tool call events', () => {
     const manager = new ToolCallManager([mockWeatherTool])
 
-    manager.addToolCallChunk({
-      toolCall: {
-        id: 'call_123',
-        type: 'function',
-        function: { name: 'get_weather', arguments: '{"loc' },
-      },
+    manager.addToolCallStartEvent({
+      type: 'TOOL_CALL_START',
+      toolCallId: 'call_123',
+      toolName: 'get_weather',
+      timestamp: Date.now(),
       index: 0,
     })
 
-    manager.addToolCallChunk({
-      toolCall: {
-        id: 'call_123',
-        type: 'function',
-        function: { name: '', arguments: 'ation":"Paris"}' },
-      },
-      index: 0,
+    manager.addToolCallArgsEvent({
+      type: 'TOOL_CALL_ARGS',
+      toolCallId: 'call_123',
+      timestamp: Date.now(),
+      delta: '{"loc',
+    })
+
+    manager.addToolCallArgsEvent({
+      type: 'TOOL_CALL_ARGS',
+      toolCallId: 'call_123',
+      timestamp: Date.now(),
+      delta: 'ation":"Paris"}',
     })
 
     const toolCalls = manager.getToolCalls()
@@ -70,22 +74,27 @@ describe('ToolCallManager', () => {
     const manager = new ToolCallManager([mockWeatherTool])
 
     // Add complete tool call
-    manager.addToolCallChunk({
-      toolCall: {
-        id: 'call_123',
-        type: 'function',
-        function: { name: 'get_weather', arguments: '{}' },
-      },
+    manager.addToolCallStartEvent({
+      type: 'TOOL_CALL_START',
+      toolCallId: 'call_123',
+      toolName: 'get_weather',
+      timestamp: Date.now(),
       index: 0,
     })
 
-    // Add incomplete tool call (no name)
-    manager.addToolCallChunk({
-      toolCall: {
-        id: 'call_456',
-        type: 'function',
-        function: { name: '', arguments: '{}' },
-      },
+    manager.addToolCallArgsEvent({
+      type: 'TOOL_CALL_ARGS',
+      toolCallId: 'call_123',
+      timestamp: Date.now(),
+      delta: '{}',
+    })
+
+    // Add incomplete tool call (no name - empty toolName)
+    manager.addToolCallStartEvent({
+      type: 'TOOL_CALL_START',
+      toolCallId: 'call_456',
+      toolName: '',
+      timestamp: Date.now(),
       index: 1,
     })
 
@@ -94,26 +103,32 @@ describe('ToolCallManager', () => {
     expect(toolCalls[0]?.id).toBe('call_123')
   })
 
-  it('should execute tools and emit tool_result chunks', async () => {
+  it('should execute tools and emit TOOL_CALL_END events', async () => {
     const manager = new ToolCallManager([mockWeatherTool])
 
-    manager.addToolCallChunk({
-      toolCall: {
-        id: 'call_123',
-        type: 'function',
-        function: { name: 'get_weather', arguments: '{"location":"Paris"}' },
-      },
+    manager.addToolCallStartEvent({
+      type: 'TOOL_CALL_START',
+      toolCallId: 'call_123',
+      toolName: 'get_weather',
+      timestamp: Date.now(),
       index: 0,
     })
 
+    manager.addToolCallArgsEvent({
+      type: 'TOOL_CALL_ARGS',
+      toolCallId: 'call_123',
+      timestamp: Date.now(),
+      delta: '{"location":"Paris"}',
+    })
+
     const { chunks: emittedChunks, result: finalResult } =
-      await collectGeneratorOutput(manager.executeTools(mockDoneChunk))
+      await collectGeneratorOutput(manager.executeTools(mockFinishedEvent))
 
-    // Should emit one tool_result chunk
+    // Should emit one TOOL_CALL_END event
     expect(emittedChunks).toHaveLength(1)
-    expect(emittedChunks[0]?.type).toBe('tool_result')
+    expect(emittedChunks[0]?.type).toBe('TOOL_CALL_END')
     expect(emittedChunks[0]?.toolCallId).toBe('call_123')
-    expect(emittedChunks[0]?.content).toContain('temp')
+    expect(emittedChunks[0]?.result).toContain('temp')
 
     // Should return one tool result message
     expect(finalResult).toHaveLength(1)
@@ -136,23 +151,30 @@ describe('ToolCallManager', () => {
 
     const manager = new ToolCallManager([errorTool])
 
-    manager.addToolCallChunk({
-      toolCall: {
-        id: 'call_123',
-        type: 'function',
-        function: { name: 'error_tool', arguments: '{}' },
-      },
+    manager.addToolCallStartEvent({
+      type: 'TOOL_CALL_START',
+      toolCallId: 'call_123',
+      toolName: 'error_tool',
+      timestamp: Date.now(),
       index: 0,
     })
 
+    manager.addToolCallArgsEvent({
+      type: 'TOOL_CALL_ARGS',
+      toolCallId: 'call_123',
+      timestamp: Date.now(),
+      delta: '{}',
+    })
+
     // Properly consume the generator
     const { chunks, result: toolResults } = await collectGeneratorOutput(
-      manager.executeTools(mockDoneChunk),
+      manager.executeTools(mockFinishedEvent),
     )
 
     // Should still emit chunk with error message
     expect(chunks).toHaveLength(1)
-    expect(chunks[0]?.content).toContain('Error executing tool: Tool failed')
+    expect(chunks[0]?.type).toBe('TOOL_CALL_END')
+    expect(chunks[0]?.result).toContain('Error executing tool: Tool failed')
 
     // Should still return tool result message
     expect(toolResults).toHaveLength(1)
@@ -169,20 +191,27 @@ describe('ToolCallManager', () => {
 
     const manager = new ToolCallManager([noExecuteTool])
 
-    manager.addToolCallChunk({
-      toolCall: {
-        id: 'call_123',
-        type: 'function',
-        function: { name: 'no_execute', arguments: '{}' },
-      },
+    manager.addToolCallStartEvent({
+      type: 'TOOL_CALL_START',
+      toolCallId: 'call_123',
+      toolName: 'no_execute',
+      timestamp: Date.now(),
       index: 0,
     })
 
+    manager.addToolCallArgsEvent({
+      type: 'TOOL_CALL_ARGS',
+      toolCallId: 'call_123',
+      timestamp: Date.now(),
+      delta: '{}',
+    })
+
     const { chunks, result: toolResults } = await collectGeneratorOutput(
-      manager.executeTools(mockDoneChunk),
+      manager.executeTools(mockFinishedEvent),
     )
 
-    expect(chunks[0]?.content).toContain('does not have an execute function')
+    expect(chunks[0]?.type).toBe('TOOL_CALL_END')
+    expect(chunks[0]?.result).toContain('does not have an execute function')
     expect(toolResults[0]?.content).toContain(
       'does not have an execute function',
     )
@@ -191,12 +220,11 @@ describe('ToolCallManager', () => {
   it('should clear tool calls', () => {
     const manager = new ToolCallManager([mockWeatherTool])
 
-    manager.addToolCallChunk({
-      toolCall: {
-        id: 'call_123',
-        type: 'function',
-        function: { name: 'get_weather', arguments: '{}' },
-      },
+    manager.addToolCallStartEvent({
+      type: 'TOOL_CALL_START',
+      toolCallId: 'call_123',
+      toolName: 'get_weather',
+      timestamp: Date.now(),
       index: 0,
     })
 
@@ -223,32 +251,44 @@ describe('ToolCallManager', () => {
     const manager = new ToolCallManager([mockWeatherTool, calculateTool])
 
     // Add two different tool calls
-    manager.addToolCallChunk({
-      toolCall: {
-        id: 'call_weather',
-        type: 'function',
-        function: { name: 'get_weather', arguments: '{"location":"Paris"}' },
-      },
+    manager.addToolCallStartEvent({
+      type: 'TOOL_CALL_START',
+      toolCallId: 'call_weather',
+      toolName: 'get_weather',
+      timestamp: Date.now(),
       index: 0,
     })
 
-    manager.addToolCallChunk({
-      toolCall: {
-        id: 'call_calc',
-        type: 'function',
-        function: { name: 'calculate', arguments: '{"expression":"5+3"}' },
-      },
+    manager.addToolCallArgsEvent({
+      type: 'TOOL_CALL_ARGS',
+      toolCallId: 'call_weather',
+      timestamp: Date.now(),
+      delta: '{"location":"Paris"}',
+    })
+
+    manager.addToolCallStartEvent({
+      type: 'TOOL_CALL_START',
+      toolCallId: 'call_calc',
+      toolName: 'calculate',
+      timestamp: Date.now(),
       index: 1,
     })
 
+    manager.addToolCallArgsEvent({
+      type: 'TOOL_CALL_ARGS',
+      toolCallId: 'call_calc',
+      timestamp: Date.now(),
+      delta: '{"expression":"5+3"}',
+    })
+
     const toolCalls = manager.getToolCalls()
     expect(toolCalls).toHaveLength(2)
 
     const { chunks, result: toolResults } = await collectGeneratorOutput(
-      manager.executeTools(mockDoneChunk),
+      manager.executeTools(mockFinishedEvent),
     )
 
-    // Should emit two tool_result chunks
+    // Should emit two TOOL_CALL_END events
     expect(chunks).toHaveLength(2)
     expect(chunks[0]?.toolCallId).toBe('call_weather')
     expect(chunks[1]?.toolCallId).toBe('call_calc')
@@ -258,4 +298,78 @@ describe('ToolCallManager', () => {
     expect(toolResults[0]?.toolCallId).toBe('call_weather')
     expect(toolResults[1]?.toolCallId).toBe('call_calc')
   })
+
+  describe('AG-UI Event Methods', () => {
+    it('should handle TOOL_CALL_START events', () => {
+      const manager = new ToolCallManager([mockWeatherTool])
+
+      manager.addToolCallStartEvent({
+        type: 'TOOL_CALL_START',
+        toolCallId: 'call_123',
+        toolName: 'get_weather',
+        timestamp: Date.now(),
+        index: 0,
+      })
+
+      const toolCalls = manager.getToolCalls()
+      expect(toolCalls).toHaveLength(1)
+      expect(toolCalls[0]?.id).toBe('call_123')
+      expect(toolCalls[0]?.function.name).toBe('get_weather')
+      expect(toolCalls[0]?.function.arguments).toBe('')
+    })
+
+    it('should accumulate TOOL_CALL_ARGS events', () => {
+      const manager = new ToolCallManager([mockWeatherTool])
+
+      manager.addToolCallStartEvent({
+        type: 'TOOL_CALL_START',
+        toolCallId: 'call_123',
+        toolName: 'get_weather',
+        timestamp: Date.now(),
+        index: 0,
+      })
+
+      manager.addToolCallArgsEvent({
+        type: 'TOOL_CALL_ARGS',
+        toolCallId: 'call_123',
+        timestamp: Date.now(),
+        delta: '{"loc',
+      })
+
+      manager.addToolCallArgsEvent({
+        type: 'TOOL_CALL_ARGS',
+        toolCallId: 'call_123',
+        timestamp: Date.now(),
+        delta: 'ation":"Paris"}',
+      })
+
+      const toolCalls = manager.getToolCalls()
+      expect(toolCalls).toHaveLength(1)
+      expect(toolCalls[0]?.function.arguments).toBe('{"location":"Paris"}')
+    })
+
+    it('should complete tool calls with TOOL_CALL_END events', () => {
+      const manager = new ToolCallManager([mockWeatherTool])
+
+      manager.addToolCallStartEvent({
+        type: 'TOOL_CALL_START',
+        toolCallId: 'call_123',
+        toolName: 'get_weather',
+        timestamp: Date.now(),
+        index: 0,
+      })
+
+      manager.completeToolCall({
+        type: 'TOOL_CALL_END',
+        toolCallId: 'call_123',
+        toolName: 'get_weather',
+        timestamp: Date.now(),
+        input: { location: 'New York' },
+      })
+
+      const toolCalls = manager.getToolCalls()
+      expect(toolCalls).toHaveLength(1)
+      expect(toolCalls[0]?.function.arguments).toBe('{"location":"New York"}')
+    })
+  })
 })
diff --git a/packages/typescript/smoke-tests/adapters/src/harness.ts b/packages/typescript/smoke-tests/adapters/src/harness.ts
index 0d560701..bb3f3ed0 100644
--- a/packages/typescript/smoke-tests/adapters/src/harness.ts
+++ b/packages/typescript/smoke-tests/adapters/src/harness.ts
@@ -182,6 +182,9 @@ export async function captureStream(opts: {
   let assistantDraft: any | null = null
   let lastAssistantMessage: any | null = null
 
+  // Track AG-UI tool calls in progress
+  const toolCallsInProgress = new Map<string, { name: string; args: string }>()
+
   for await (const chunk of stream) {
     chunkIndex++
     const chunkData: any = {
@@ -189,82 +192,124 @@ export async function captureStream(opts: {
       index: chunkIndex,
       type: chunk.type,
       timestamp: chunk.timestamp,
-      id: chunk.id,
+      id: (chunk as any).id,
       model: chunk.model,
     }
 
-    if (chunk.type === 'content') {
+    // AG-UI TEXT_MESSAGE_CONTENT event
+    if (chunk.type === 'TEXT_MESSAGE_CONTENT') {
       chunkData.delta = chunk.delta
       chunkData.content = chunk.content
-      chunkData.role = chunk.role
-      const delta = chunk.delta || chunk.content || ''
+      chunkData.role = 'assistant'
+      const delta = chunk.delta || ''
       fullResponse += delta
 
-      if (chunk.role === 'assistant') {
-        if (!assistantDraft) {
-          assistantDraft = {
-            role: 'assistant',
-            content: chunk.content || '',
-            toolCalls: [],
-          }
-        } else {
-          assistantDraft.content = (assistantDraft.content || '') + delta
+      if (!assistantDraft) {
+        assistantDraft = {
+          role: 'assistant',
+          content: chunk.content || '',
+          toolCalls: [],
         }
+      } else {
+        assistantDraft.content = (assistantDraft.content || '') + delta
       }
-    } else if (chunk.type === 'tool_call') {
-      const id = chunk.toolCall.id
-      const existing = toolCallMap.get(id) || {
-        id,
-        name: chunk.toolCall.function.name,
-        arguments: '',
-      }
-      existing.arguments += chunk.toolCall.function.arguments || ''
-      toolCallMap.set(id, existing)
-
-      chunkData.toolCall = chunk.toolCall
+    }
+    // AG-UI TOOL_CALL_START event
+    else if (chunk.type === 'TOOL_CALL_START') {
+      const id = chunk.toolCallId
+      toolCallsInProgress.set(id, {
+        name: chunk.toolName,
+        args: '',
+      })
 
       if (!assistantDraft) {
         assistantDraft = { role: 'assistant', content: null, toolCalls: [] }
       }
-      const existingToolCall = assistantDraft.toolCalls?.find(
-        (tc: any) => tc.id === id,
-      )
-      if (existingToolCall) {
-        existingToolCall.function.arguments = existing.arguments
-      } else {
-        assistantDraft.toolCalls?.push({
-          ...chunk.toolCall,
-          function: {
-            ...chunk.toolCall.function,
-            arguments: existing.arguments,
-          },
-        })
+
+      chunkData.toolCallId = chunk.toolCallId
+      chunkData.toolName = chunk.toolName
+    }
+    // AG-UI TOOL_CALL_ARGS event
+    else if (chunk.type === 'TOOL_CALL_ARGS') {
+      const id = chunk.toolCallId
+      const existing = toolCallsInProgress.get(id)
+      if (existing) {
+        existing.args = chunk.args || existing.args + (chunk.delta || '')
       }
-    } else if (chunk.type === 'tool_result') {
+
       chunkData.toolCallId = chunk.toolCallId
-      chunkData.content = chunk.content
-      toolResults.push({
-        toolCallId: chunk.toolCallId,
-        content: chunk.content,
-      })
-      reconstructedMessages.push({
-        role: 'tool',
-        toolCallId: chunk.toolCallId,
-        content: chunk.content,
+      chunkData.delta = chunk.delta
+      chunkData.args = chunk.args
+    }
+    // AG-UI TOOL_CALL_END event
+    else if (chunk.type === 'TOOL_CALL_END') {
+      const id = chunk.toolCallId
+      const inProgress = toolCallsInProgress.get(id)
+      const name = chunk.toolName || inProgress?.name || ''
+      const args =
+        inProgress?.args || (chunk.input ? JSON.stringify(chunk.input) : '')
+
+      toolCallMap.set(id, {
+        id,
+        name,
+        arguments: args,
       })
-    } else if (chunk.type === 'approval-requested') {
-      const approval: ApprovalCapture = {
-        toolCallId: chunk.toolCallId,
-        toolName: chunk.toolName,
-        input: chunk.input,
-        approval: chunk.approval,
+
+      // Add to assistant draft
+      if (!assistantDraft) {
+        assistantDraft = { role: 'assistant', content: null, toolCalls: [] }
       }
+      assistantDraft.toolCalls?.push({
+        id,
+        type: 'function',
+        function: {
+          name,
+          arguments: args,
+        },
+      })
+
       chunkData.toolCallId = chunk.toolCallId
       chunkData.toolName = chunk.toolName
       chunkData.input = chunk.input
-      chunkData.approval = chunk.approval
-      approvalRequests.push(approval)
-    } else if (chunk.type === 'done') {
+
+      // AG-UI tool results are included in TOOL_CALL_END events
+      if (chunk.result !== undefined) {
+        chunkData.result = chunk.result
+        toolResults.push({
+          toolCallId: id,
+          content: chunk.result,
+        })
+        reconstructedMessages.push({
+          role: 'tool',
+          toolCallId: id,
+          content: chunk.result,
+        })
+      }
+    }
+    // AG-UI CUSTOM events (approval requests, tool inputs, etc.)
+    else if (chunk.type === 'CUSTOM') {
+      chunkData.name = chunk.name
+      chunkData.data = chunk.data
+
+      // Handle approval-requested CUSTOM events
+      if (chunk.name === 'approval-requested' && chunk.data) {
+        const data = chunk.data as {
+          toolCallId: string
+          toolName: string
+          input: any
+          approval: any
+        }
+        const approval: ApprovalCapture = {
+          toolCallId: data.toolCallId,
+          toolName: data.toolName,
+          input: data.input,
+          approval: data.approval,
+        }
+        approvalRequests.push(approval)
+      }
+    }
+    // AG-UI RUN_FINISHED event
+    else if (chunk.type === 'RUN_FINISHED') {
       chunkData.finishReason = chunk.finishReason
       chunkData.usage = chunk.usage
       if (chunk.finishReason === 'stop' && assistantDraft) {
diff --git a/packages/typescript/smoke-tests/adapters/src/tests/sms-summarize-stream.ts b/packages/typescript/smoke-tests/adapters/src/tests/sms-summarize-stream.ts
index 3ee43752..076a03eb 100644
--- a/packages/typescript/smoke-tests/adapters/src/tests/sms-summarize-stream.ts
+++ b/packages/typescript/smoke-tests/adapters/src/tests/sms-summarize-stream.ts
@@ -58,8 +58,13 @@ export async function runSMS(
         content: 'content' in chunk ? chunk.content : undefined,
       })
 
-      if (chunk.type === 'content') {
-        finalContent = chunk.content
+      // AG-UI TEXT_MESSAGE_CONTENT event
+      if (chunk.type === 'TEXT_MESSAGE_CONTENT') {
+        if (chunk.content) {
+          finalContent = chunk.content
+        } else if (chunk.delta) {
+          finalContent += chunk.delta
+        }
       }
     }
 
diff --git a/packages/typescript/smoke-tests/e2e/src/routes/api.mock-chat.ts b/packages/typescript/smoke-tests/e2e/src/routes/api.mock-chat.ts
new file mode 100644
index 00000000..91b1f097
--- /dev/null
+++ b/packages/typescript/smoke-tests/e2e/src/routes/api.mock-chat.ts
@@ -0,0 +1,360 @@
+import { createFileRoute } from '@tanstack/react-router'
+import { toServerSentEventsStream } from '@tanstack/ai'
+import type { StreamChunk } from '@tanstack/ai'
+
+/**
+ * Mock chat scenarios for deterministic E2E testing.
+ * Each scenario returns a predefined sequence of AG-UI events.
+ */
+type ScenarioName =
+  | 'simple-text'
+  | 'tool-call'
+  | 'multi-tool'
+  | 'text-tool-text'
+  | 'error'
+
+interface MockScenario {
+  chunks: Array<StreamChunk>
+  delayMs?: number
+}
+
+const scenarios: Record<ScenarioName, MockScenario> = {
+  'simple-text': {
+    chunks: [
+      {
+        type: 'RUN_STARTED',
+        runId: 'mock-run-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'TEXT_MESSAGE_START',
+        messageId: 'mock-msg-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'mock-msg-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        delta: 'Hello! ',
+        content: 'Hello! ',
+      },
+      {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'mock-msg-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        delta: 'This is a mock response.',
+        content: 'Hello! This is a mock response.',
+      },
+      {
+        type: 'TEXT_MESSAGE_END',
+        messageId: 'mock-msg-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'RUN_FINISHED',
+        runId: 'mock-run-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        finishReason: 'stop',
+      },
+    ],
+    delayMs: 10,
+  },
+
+  'tool-call': {
+    chunks: [
+      {
+        type: 'RUN_STARTED',
+        runId: 'mock-run-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'TOOL_CALL_START',
+        toolCallId: 'mock-tc-1',
+        toolName: 'get_weather',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        index: 0,
+      },
+      {
+        type: 'TOOL_CALL_ARGS',
+        toolCallId: 'mock-tc-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        delta: '{"city":',
+      },
+      {
+        type: 'TOOL_CALL_ARGS',
+        toolCallId: 'mock-tc-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        delta: '"New York"}',
+      },
+      {
+        type: 'TOOL_CALL_END',
+        toolCallId: 'mock-tc-1',
+        toolName: 'get_weather',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'CUSTOM',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        name: 'tool-input-available',
+        data: {
+          toolCallId: 'mock-tc-1',
+          toolName: 'get_weather',
+          input: { city: 'New York' },
+        },
+      },
+      {
+        type: 'RUN_FINISHED',
+        runId: 'mock-run-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        finishReason: 'tool_calls',
+      },
+    ],
+    delayMs: 10,
+  },
+
+  'multi-tool': {
+    chunks: [
+      {
+        type: 'RUN_STARTED',
+        runId: 'mock-run-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'TOOL_CALL_START',
+        toolCallId: 'mock-tc-1',
+        toolName: 'get_weather',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        index: 0,
+      },
+      {
+        type: 'TOOL_CALL_START',
+        toolCallId: 'mock-tc-2',
+        toolName: 'get_time',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        index: 1,
+      },
+      {
+        type: 'TOOL_CALL_ARGS',
+        toolCallId: 'mock-tc-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        delta: '{"city":"NYC"}',
+      },
+      {
+        type: 'TOOL_CALL_ARGS',
+        toolCallId: 'mock-tc-2',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        delta: '{"timezone":"EST"}',
+      },
+      {
+        type: 'TOOL_CALL_END',
+        toolCallId: 'mock-tc-1',
+        toolName: 'get_weather',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'TOOL_CALL_END',
+        toolCallId: 'mock-tc-2',
+        toolName: 'get_time',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'CUSTOM',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        name: 'tool-input-available',
+        data: {
+          toolCallId: 'mock-tc-1',
+          toolName: 'get_weather',
+          input: { city: 'NYC' },
+        },
+      },
+      {
+        type: 'CUSTOM',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        name: 'tool-input-available',
+        data: {
+          toolCallId: 'mock-tc-2',
+          toolName: 'get_time',
+          input: { timezone: 'EST' },
+        },
+      },
+      {
+        type: 'RUN_FINISHED',
+        runId: 'mock-run-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        finishReason: 'tool_calls',
+      },
+    ],
+    delayMs: 10,
+  },
+
+  'text-tool-text': {
+    chunks: [
+      {
+        type: 'RUN_STARTED',
+        runId: 'mock-run-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'TEXT_MESSAGE_START',
+        messageId: 'mock-msg-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'mock-msg-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        delta: 'Let me check the weather for you.',
+        content: 'Let me check the weather for you.',
+      },
+      {
+        type: 'TEXT_MESSAGE_END',
+        messageId: 'mock-msg-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'TOOL_CALL_START',
+        toolCallId: 'mock-tc-1',
+        toolName: 'get_weather',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        index: 0,
+      },
+      {
+        type: 'TOOL_CALL_ARGS',
+        toolCallId: 'mock-tc-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        delta: '{"city":"Paris"}',
+      },
+      {
+        type: 'TOOL_CALL_END',
+        toolCallId: 'mock-tc-1',
+        toolName: 'get_weather',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'CUSTOM',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        name: 'tool-input-available',
+        data: {
+          toolCallId: 'mock-tc-1',
+          toolName: 'get_weather',
+          input: { city: 'Paris' },
+        },
+      },
+      {
+        type: 'RUN_FINISHED',
+        runId: 'mock-run-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        finishReason: 'tool_calls',
+      },
+    ],
+    delayMs: 10,
+  },
+
+  error: {
+    chunks: [
+      {
+        type: 'RUN_STARTED',
+        runId: 'mock-run-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+      },
+      {
+        type: 'RUN_ERROR',
+        runId: 'mock-run-1',
+        model: 'mock-model',
+        timestamp: Date.now(),
+        error: {
+          message: 'Mock error: Something went wrong',
+          code: 'MOCK_ERROR',
+        },
+      },
+    ],
+    delayMs: 10,
+  },
+}
+
+/**
+ * Create an async generator from scenario chunks
+ */
+async function* createMockStream(
+  scenario: MockScenario,
+): AsyncGenerator<StreamChunk> {
+  for (const chunk of scenario.chunks) {
+    if (scenario.delayMs) {
+      await new Promise((resolve) => setTimeout(resolve, scenario.delayMs))
+    }
+    yield { ...chunk, timestamp: Date.now() }
+  }
+}
+
+export const Route = createFileRoute('/api/mock-chat')({
+  server: {
+    handlers: {
+      POST: async ({ request }) => {
+        const body = await request.json()
+        // fetchServerSentEvents wraps the body in a `data` property
+        const scenarioName =
+          (body.data?.scenario as ScenarioName) ||
+          (body.scenario as ScenarioName) ||
+          'simple-text'
+
+        const scenario = scenarios[scenarioName]
+        if (!scenario) {
+          return new Response(
+            JSON.stringify({ error: `Unknown scenario: ${scenarioName}` }),
+            {
+              status: 400,
+              headers: { 'Content-Type': 'application/json' },
+            },
+          )
+        }
+
+        const stream = createMockStream(scenario)
+        const abortController = new AbortController()
+
+        // Use the same SSE stream helper as the real API
+        const sseStream = toServerSentEventsStream(stream, abortController)
+
+        return new Response(sseStream, {
+          headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+          },
+        })
+      },
+    },
+  },
+})
diff --git a/packages/typescript/smoke-tests/e2e/src/routes/index.tsx b/packages/typescript/smoke-tests/e2e/src/routes/index.tsx
index 57cd2b79..20b404b0 100644
--- a/packages/typescript/smoke-tests/e2e/src/routes/index.tsx
+++ b/packages/typescript/smoke-tests/e2e/src/routes/index.tsx
@@ -1,12 +1,118 @@
-import { useState } from 'react'
+import { useState, useMemo } from 'react'
 import { createFileRoute } from '@tanstack/react-router'
 import { useChat, fetchServerSentEvents } from '@tanstack/ai-react'
+import type { UIMessage } from '@tanstack/ai-client'
+
+type ApiMode = 'real' | 'mock'
+type MockScenario =
+  | 'simple-text'
+  | 'tool-call'
+  | 'multi-tool'
+  | 'text-tool-text'
+  | 'error'
+
+/**
+ * Create a connection adapter that sends the mock scenario in the body
+ */
+function createMockConnection(scenario: MockScenario) {
+  return {
+    async *connect(
+      messages: Array<any>,
+      body: Record<string, any>,
+      abortSignal?: AbortSignal,
+    ) {
+      const response = await fetch('/api/mock-chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ ...body, messages, scenario }),
+        signal: abortSignal,
+      })
+
+      if (!response.ok) {
+        throw new Error(`Mock API error: ${response.status}`)
+      }
+
+      const reader = response.body?.getReader()
+      if (!reader) return
+
+      const decoder = new TextDecoder()
+      let buffer = ''
+
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+        const lines = buffer.split('\n')
+        buffer = lines.pop() || ''
+
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6)
+            if (data === '[DONE]') continue
+            try {
+              yield JSON.parse(data)
+            } catch {
+              // Skip invalid JSON
+            }
+          }
+        }
+      }
+    },
+  }
+}
+
+/**
+ * Extract statistics from messages for testing
+ */
+function getMessageStats(messages: Array<UIMessage>) {
+  const userMessages = messages.filter((m) => m.role === 'user')
+  const assistantMessages = messages.filter((m) => m.role === 'assistant')
+
+  const toolCallParts = assistantMessages.flatMap((m) =>
+    m.parts.filter((p) => p.type === 'tool-call'),
+  )
+
+  const textParts = assistantMessages.flatMap((m) =>
+    m.parts.filter((p) => p.type === 'text'),
+  )
+
+  const toolNames = toolCallParts.map((p) =>
+    p.type === 'tool-call' ? p.name : '',
+  )
+
+  return {
+    totalMessages: messages.length,
+    userMessageCount: userMessages.length,
+    assistantMessageCount: assistantMessages.length,
+    toolCallCount: toolCallParts.length,
+    textPartCount: textParts.length,
+    toolNames: toolNames.join(','),
+    hasToolCalls: toolCallParts.length > 0,
+    lastAssistantText:
+      textParts.length > 0 && textParts[textParts.length - 1]?.type === 'text'
+        ? textParts[textParts.length - 1].content
+        : '',
+  }
+}
 
 function ChatPage() {
-  const { messages, sendMessage, isLoading, stop } = useChat({
-    connection: fetchServerSentEvents('/api/tanchat'),
+  const [apiMode, setApiMode] = useState<ApiMode>('real')
+  const [mockScenario, setMockScenario] = useState<MockScenario>('simple-text')
+
+  const connection = useMemo(() => {
+    if (apiMode === 'mock') {
+      return createMockConnection(mockScenario)
+    }
+    return fetchServerSentEvents('/api/tanchat')
+  }, [apiMode, mockScenario])
+
+  const { messages, sendMessage, isLoading, stop, error } = useChat({
+    connection,
   })
+
   const [input, setInput] = useState('')
+  const stats = getMessageStats(messages)
 
   return (
     <div
@@ -16,7 +122,68 @@ function ChatPage() {
         height: '100vh',
         padding: '20px',
       }}
+      data-testid="chat-page"
+      data-api-mode={apiMode}
+      data-mock-scenario={mockScenario}
+      data-is-loading={isLoading.toString()}
+      data-has-error={!!error}
+      data-message-count={stats.totalMessages}
+      data-user-message-count={stats.userMessageCount}
+      data-assistant-message-count={stats.assistantMessageCount}
+      data-tool-call-count={stats.toolCallCount}
+      data-has-tool-calls={stats.hasToolCalls.toString()}
+      data-tool-names={stats.toolNames}
     >
+      {/* API Mode Selector */}
+      <div
+        id="api-mode-selector"
+        style={{
+          display: 'flex',
+          gap: '10px',
+          marginBottom: '10px',
+          alignItems: 'center',
+        }}
+      >
+        <label>
+          <input
+            type="radio"
+            name="apiMode"
+            value="real"
+            checked={apiMode === 'real'}
+            onChange={() => setApiMode('real')}
+            data-testid="api-mode-real"
+          />
+          Real API
+        </label>
+        <label>
+          <input
+            type="radio"
+            name="apiMode"
+            value="mock"
+            checked={apiMode === 'mock'}
+            onChange={() => setApiMode('mock')}
+            data-testid="api-mode-mock"
+          />
+          Mock API
+        </label>
+
+        {apiMode === 'mock' && (
+          <select
+            id="mock-scenario-select"
+            value={mockScenario}
+            onChange={(e) => setMockScenario(e.target.value as MockScenario)}
+            data-testid="mock-scenario-select"
+            style={{ marginLeft: '10px', padding: '5px' }}
+          >
+            <option value="simple-text">Simple Text</option>
+            <option value="tool-call">Tool Call</option>
+            <option value="multi-tool">Multiple Tools</option>
+            <option value="text-tool-text">Text + Tool + Text</option>
+            <option value="error">Error</option>
+          </select>
+        )}
+      </div>
+
       {/* Input area */}
       <div style={{ display: 'flex', gap: '10px', marginBottom: '20px' }}>
         <input
@@ -68,6 +235,7 @@ function ChatPage() {
           <button
             id="stop-button"
             onClick={stop}
+            data-testid="stop-button"
             style={{
               padding: '10px 20px',
               fontSize: '14px',
@@ -83,6 +251,25 @@ function ChatPage() {
         )}
       </div>
 
+      {/* Error Display */}
+      {error && (
+        <div
+          id="error-display"
+          data-testid="error-display"
+          data-error-message={error.message}
+          style={{
+            padding: '10px',
+            marginBottom: '10px',
+            backgroundColor: '#ffebee',
+            border: '1px solid #f44336',
+            borderRadius: '4px',
+            color: '#c62828',
+          }}
+        >
+          Error: {error.message}
+        </div>
+      )}
+
       {/* JSON Messages Display */}
       <div
         id="messages-json"
@@ -99,6 +286,7 @@ function ChatPage() {
       >
         <pre
           id="messages-json-content"
+          data-testid="messages-json-content"
           style={{ margin: 0, whiteSpace: 'pre-wrap', wordBreak: 'break-word' }}
         >
           {JSON.stringify(messages, null, 2)}
diff --git a/packages/typescript/smoke-tests/e2e/src/routes/mock.tsx b/packages/typescript/smoke-tests/e2e/src/routes/mock.tsx
new file mode 100644
index 00000000..2d95d950
--- /dev/null
+++ b/packages/typescript/smoke-tests/e2e/src/routes/mock.tsx
@@ -0,0 +1,227 @@
+import { useMemo, useState } from 'react'
+import { createFileRoute, useSearch } from '@tanstack/react-router'
+import { useChat, fetchServerSentEvents } from '@tanstack/ai-react'
+import type { UIMessage } from '@tanstack/ai-client'
+
+type MockScenario =
+  | 'simple-text'
+  | 'tool-call'
+  | 'multi-tool'
+  | 'text-tool-text'
+  | 'error'
+
+const VALID_SCENARIOS: MockScenario[] = [
+  'simple-text',
+  'tool-call',
+  'multi-tool',
+  'text-tool-text',
+  'error',
+]
+
+/**
+ * Extract statistics from messages for testing
+ */
+function getMessageStats(messages: Array<UIMessage>) {
+  const userMessages = messages.filter((m) => m.role === 'user')
+  const assistantMessages = messages.filter((m) => m.role === 'assistant')
+
+  const toolCallParts = assistantMessages.flatMap((m) =>
+    m.parts.filter((p) => p.type === 'tool-call'),
+  )
+
+  const textParts = assistantMessages.flatMap((m) =>
+    m.parts.filter((p) => p.type === 'text'),
+  )
+
+  const toolNames = toolCallParts.map((p) =>
+    p.type === 'tool-call' ? p.name : '',
+  )
+
+  return {
+    totalMessages: messages.length,
+    userMessageCount: userMessages.length,
+    assistantMessageCount: assistantMessages.length,
+    toolCallCount: toolCallParts.length,
+    textPartCount: textParts.length,
+    toolNames: toolNames.join(','),
+    hasToolCalls: toolCallParts.length > 0,
+    lastAssistantText:
+      textParts.length > 0 && textParts[textParts.length - 1]?.type === 'text'
+        ? textParts[textParts.length - 1].content
+        : '',
+  }
+}
+
+function MockChatPage() {
+  const { scenario: searchScenario } = useSearch({ from: '/mock' })
+
+  // Use scenario from URL, validated
+  const scenario: MockScenario = VALID_SCENARIOS.includes(
+    searchScenario as MockScenario,
+  )
+    ? (searchScenario as MockScenario)
+    : 'simple-text'
+
+  // Use fetchServerSentEvents for the mock endpoint
+  const connection = useMemo(() => {
+    return fetchServerSentEvents('/api/mock-chat')
+  }, [])
+
+  const { messages, sendMessage, isLoading, stop, error } = useChat({
+    connection,
+    body: { scenario },
+  })
+
+  const [input, setInput] = useState('')
+  const stats = getMessageStats(messages)
+
+  return (
+    <div
+      style={{
+        display: 'flex',
+        flexDirection: 'column',
+        height: '100vh',
+        padding: '20px',
+      }}
+      data-testid="chat-page"
+      data-mock-scenario={scenario}
+      data-is-loading={isLoading.toString()}
+      data-has-error={!!error}
+      data-message-count={stats.totalMessages}
+      data-user-message-count={stats.userMessageCount}
+      data-assistant-message-count={stats.assistantMessageCount}
+      data-tool-call-count={stats.toolCallCount}
+      data-has-tool-calls={stats.hasToolCalls.toString()}
+      data-tool-names={stats.toolNames}
+    >
+      {/* Scenario indicator - scenario is controlled via URL param */}
+      <div
+        style={{
+          marginBottom: '10px',
+          padding: '8px',
+          backgroundColor: '#e3f2fd',
+          borderRadius: '4px',
+        }}
+      >
+        <strong>Mock Scenario:</strong> {scenario}
+      </div>
+
+      {/* Input area */}
+      <div style={{ display: 'flex', gap: '10px', marginBottom: '20px' }}>
+        <input
+          id="chat-input"
+          type="text"
+          value={input}
+          onChange={(e) => setInput(e.target.value)}
+          onKeyDown={(e) => {
+            if (e.key === 'Enter' && input.trim() && !isLoading) {
+              sendMessage(input)
+              setInput('')
+            }
+          }}
+          placeholder="Type a message..."
+          disabled={isLoading}
+          style={{
+            flex: 1,
+            padding: '10px',
+            fontSize: '14px',
+            border: '1px solid #ccc',
+            borderRadius: '4px',
+          }}
+        />
+        <button
+          id="submit-button"
+          onClick={() => {
+            if (input.trim()) {
+              sendMessage(input)
+              setInput('')
+            }
+          }}
+          data-testid="submit-button"
+          data-is-loading={isLoading.toString()}
+          style={{
+            padding: '10px 20px',
+            fontSize: '14px',
+            backgroundColor: '#007bff',
+            color: 'white',
+            border: 'none',
+            borderRadius: '4px',
+            cursor: 'pointer',
+            opacity: isLoading ? 0.7 : 1,
+          }}
+        >
+          Submit
+        </button>
+        {isLoading && (
+          <button
+            id="stop-button"
+            onClick={stop}
+            data-testid="stop-button"
+            style={{
+              padding: '10px 20px',
+              fontSize: '14px',
+              backgroundColor: '#dc3545',
+              color: 'white',
+              border: 'none',
+              borderRadius: '4px',
+              cursor: 'pointer',
+            }}
+          >
+            Stop
+          </button>
+        )}
+      </div>
+
+      {/* Error Display */}
+      {error && (
+        <div
+          id="error-display"
+          data-testid="error-display"
+          data-error-message={error.message}
+          style={{
+            padding: '10px',
+            marginBottom: '10px',
+            backgroundColor: '#ffebee',
+            border: '1px solid #f44336',
+            borderRadius: '4px',
+            color: '#c62828',
+          }}
+        >
+          Error: {error.message}
+        </div>
+      )}
+
+      {/* JSON Messages Display */}
+      <div
+        id="messages-json"
+        style={{
+          flex: 1,
+          overflow: 'auto',
+          padding: '10px',
+          backgroundColor: '#f5f5f5',
+          border: '1px solid #ddd',
+          borderRadius: '4px',
+          fontFamily: 'monospace',
+          fontSize: '12px',
+        }}
+      >
+        <pre
+          id="messages-json-content"
+          data-testid="messages-json-content"
+          style={{ margin: 0, whiteSpace: 'pre-wrap', wordBreak: 'break-word' }}
+        >
+          {JSON.stringify(messages, null, 2)}
+        </pre>
+      </div>
+    </div>
+  )
+}
+
+export const Route = createFileRoute('/mock')({
+  validateSearch: (search: Record<string, unknown>) => {
+    return {
+      scenario: search.scenario as string | undefined,
+    }
+  },
+  component: MockChatPage,
+})
diff --git a/packages/typescript/smoke-tests/e2e/tests/chat.spec.ts b/packages/typescript/smoke-tests/e2e/tests/chat.spec.ts
index fed8ff4d..e8fb5de7 100644
--- a/packages/typescript/smoke-tests/e2e/tests/chat.spec.ts
+++ b/packages/typescript/smoke-tests/e2e/tests/chat.spec.ts
@@ -1,11 +1,95 @@
-import { test, expect } from '@playwright/test'
+import { test, expect, Page } from '@playwright/test'
+
+type MockScenario =
+  | 'simple-text'
+  | 'tool-call'
+  | 'multi-tool'
+  | 'text-tool-text'
+  | 'error'
+
+/**
+ * Helper to navigate to mock page with a specific scenario
+ */
+async function goToMockScenario(page: Page, scenario: MockScenario) {
+  await page.goto(`/mock?scenario=${scenario}`)
+  await page.waitForSelector('#chat-input', { timeout: 10000 })
+
+  // Wait for hydration by checking if input is interactive
+  const input = page.locator('#chat-input')
+  await expect(input).toBeEnabled({ timeout: 10000 })
+
+  // Verify scenario is set
+  const chatPage = page.locator('[data-testid="chat-page"]')
+  await expect(chatPage).toHaveAttribute('data-mock-scenario', scenario)
+
+  // Wait for network to be idle - this helps ensure all client-side code is loaded
+  await page.waitForLoadState('networkidle')
+
+  // Additional wait for React hydration - verify the submit button is also ready
+  await expect(page.locator('#submit-button')).toBeEnabled({ timeout: 5000 })
+
+  // Small delay to ensure event handlers are attached after hydration
+  await page.waitForTimeout(100)
+}
+
+/**
+ * Helper to send a message and wait for response
+ */
+async function sendMessageAndWait(
+  page: Page,
+  message: string,
+  expectedMessageCount: number = 2,
+) {
+  const input = page.locator('#chat-input')
+  const submitButton = page.locator('#submit-button')
+  const chatPage = page.locator('[data-testid="chat-page"]')
+
+  // Clear any existing value first
+  await input.click()
+  await input.fill('')
+
+  // Use pressSequentially to properly trigger React state updates
+  await input.pressSequentially(message, { delay: 20 })
+
+  // Verify the input value was set
+  await expect(input).toHaveValue(message, { timeout: 5000 })
+
+  // Click submit
+  await submitButton.click()
+
+  // Wait for loading to START (user message should be added immediately)
+  // Then wait for it to complete
+  await expect(chatPage).toHaveAttribute('data-user-message-count', '1', {
+    timeout: 5000,
+  })
+
+  // Wait for loading to complete
+  await expect(submitButton).toHaveAttribute('data-is-loading', 'false', {
+    timeout: 30000,
+  })
+
+  // Wait for messages to be populated
+  await expect(chatPage).toHaveAttribute(
+    'data-message-count',
+    expectedMessageCount.toString(),
+    { timeout: 10000 },
+  )
+}
+
+/**
+ * Helper to parse messages from the JSON display
+ */
+async function getMessages(page: Page): Promise<Array<any>> {
+  const jsonContent = await page.locator('#messages-json-content').textContent()
+  return JSON.parse(jsonContent || '[]')
+}
 
 /**
- * Chat E2E Tests using LLM Simulator
+ * Chat E2E Tests - UI Presence
  *
  * These tests verify the chat UI loads and elements are present.
  */
-test.describe('Chat E2E Tests', () => {
+test.describe('Chat E2E Tests - UI Presence', () => {
   test('should display the chat page correctly', async ({ page }) => {
     await page.goto('/')
     await page.waitForSelector('#chat-input', { timeout: 10000 })
@@ -20,11 +104,7 @@ test.describe('Chat E2E Tests', () => {
     await page.waitForSelector('#chat-input', { timeout: 10000 })
 
     const input = page.locator('#chat-input')
-
-    // Type a message
     await input.fill('Hello, world!')
-
-    // Verify the input value
     await expect(input).toHaveValue('Hello, world!')
   })
 
@@ -35,20 +115,202 @@ test.describe('Chat E2E Tests', () => {
     await page.waitForSelector('#chat-input', { timeout: 10000 })
 
     const submitButton = page.locator('#submit-button')
-
-    // Verify button is present and has expected attributes
     await expect(submitButton).toBeVisible()
     const dataIsLoading = await submitButton.getAttribute('data-is-loading')
     expect(dataIsLoading).toBe('false')
   })
 
-  // Take screenshot on failure for debugging
-  test.afterEach(async ({ page }, testInfo) => {
-    if (testInfo.status !== testInfo.expectedStatus) {
-      await page.screenshot({
-        path: `test-results/failure-${testInfo.title.replace(/\s+/g, '-')}.png`,
-        fullPage: true,
-      })
-    }
+  test('should display mock page with scenario from URL', async ({ page }) => {
+    await page.goto('/mock?scenario=tool-call')
+    await page.waitForSelector('#chat-input', { timeout: 10000 })
+
+    const chatPage = page.locator('[data-testid="chat-page"]')
+    await expect(chatPage).toHaveAttribute('data-mock-scenario', 'tool-call')
+    await expect(page.locator('#chat-input')).toBeVisible()
+    await expect(page.locator('#submit-button')).toBeVisible()
   })
 })
+
+/**
+ * Chat E2E Tests - Text Flow with Mock API
+ *
+ * These tests verify the full text message flow using deterministic mock responses.
+ */
+test.describe('Chat E2E Tests - Text Flow (Mock API)', () => {
+  test('should send message and receive simple text response', async ({
+    page,
+  }) => {
+    await goToMockScenario(page, 'simple-text')
+    await sendMessageAndWait(page, 'Hello')
+
+    const messages = await getMessages(page)
+
+    // Should have user message and assistant message
+    expect(messages.length).toBe(2)
+
+    // Verify user message
+    const userMessage = messages[0]
+    expect(userMessage.role).toBe('user')
+    expect(userMessage.parts).toContainEqual({
+      type: 'text',
+      content: 'Hello',
+    })
+
+    // Verify assistant message has text part
+    const assistantMessage = messages[1]
+    expect(assistantMessage.role).toBe('assistant')
+
+    const textPart = assistantMessage.parts.find((p: any) => p.type === 'text')
+    expect(textPart).toBeDefined()
+    expect(textPart.content).toContain('Hello!')
+    expect(textPart.content).toContain('mock response')
+  })
+
+  test('should update data attributes correctly after message', async ({
+    page,
+  }) => {
+    await goToMockScenario(page, 'simple-text')
+    await sendMessageAndWait(page, 'Test message')
+
+    const chatPage = page.locator('[data-testid="chat-page"]')
+
+    // Verify data attributes
+    await expect(chatPage).toHaveAttribute('data-message-count', '2')
+    await expect(chatPage).toHaveAttribute('data-user-message-count', '1')
+    await expect(chatPage).toHaveAttribute('data-assistant-message-count', '1')
+    await expect(chatPage).toHaveAttribute('data-has-tool-calls', 'false')
+    await expect(chatPage).toHaveAttribute('data-tool-call-count', '0')
+  })
+})
+
+/**
+ * Chat E2E Tests - Tool Call Flow with Mock API
+ *
+ * These tests verify tool call handling using deterministic mock responses.
+ */
+test.describe('Chat E2E Tests - Tool Call Flow (Mock API)', () => {
+  test('should handle single tool call response', async ({ page }) => {
+    await goToMockScenario(page, 'tool-call')
+    await sendMessageAndWait(page, 'What is the weather?')
+
+    const messages = await getMessages(page)
+
+    // Should have user message and assistant message
+    expect(messages.length).toBe(2)
+
+    // Verify assistant message has tool-call part
+    const assistantMessage = messages[1]
+    expect(assistantMessage.role).toBe('assistant')
+
+    const toolCallPart = assistantMessage.parts.find(
+      (p: any) => p.type === 'tool-call',
+    )
+    expect(toolCallPart).toBeDefined()
+    expect(toolCallPart.name).toBe('get_weather')
+    expect(toolCallPart.id).toBe('mock-tc-1')
+
+    // Verify data attributes
+    const chatPage = page.locator('[data-testid="chat-page"]')
+    await expect(chatPage).toHaveAttribute('data-has-tool-calls', 'true')
+    await expect(chatPage).toHaveAttribute('data-tool-call-count', '1')
+    await expect(chatPage).toHaveAttribute('data-tool-names', 'get_weather')
+  })
+
+  test('should handle multiple parallel tool calls', async ({ page }) => {
+    await goToMockScenario(page, 'multi-tool')
+    await sendMessageAndWait(page, 'Weather and time please')
+
+    const messages = await getMessages(page)
+    const assistantMessage = messages[1]
+
+    // Should have 2 tool-call parts
+    const toolCallParts = assistantMessage.parts.filter(
+      (p: any) => p.type === 'tool-call',
+    )
+    expect(toolCallParts.length).toBe(2)
+
+    // Verify tool names
+    const toolNames = toolCallParts.map((p: any) => p.name)
+    expect(toolNames).toContain('get_weather')
+    expect(toolNames).toContain('get_time')
+
+    // Verify data attributes
+    const chatPage = page.locator('[data-testid="chat-page"]')
+    await expect(chatPage).toHaveAttribute('data-tool-call-count', '2')
+  })
+
+  test('should handle text followed by tool call', async ({ page }) => {
+    await goToMockScenario(page, 'text-tool-text')
+    await sendMessageAndWait(page, 'Check weather in Paris')
+
+    const messages = await getMessages(page)
+    const assistantMessage = messages[1]
+
+    // Should have both text and tool-call parts
+    const textPart = assistantMessage.parts.find((p: any) => p.type === 'text')
+    const toolCallPart = assistantMessage.parts.find(
+      (p: any) => p.type === 'tool-call',
+    )
+
+    expect(textPart).toBeDefined()
+    expect(textPart.content).toContain('Let me check the weather')
+
+    expect(toolCallPart).toBeDefined()
+    expect(toolCallPart.name).toBe('get_weather')
+
+    // Verify data attributes show both
+    const chatPage = page.locator('[data-testid="chat-page"]')
+    await expect(chatPage).toHaveAttribute('data-has-tool-calls', 'true')
+  })
+
+  test('should verify tool call arguments are correctly parsed', async ({
+    page,
+  }) => {
+    await goToMockScenario(page, 'tool-call')
+    await sendMessageAndWait(page, 'Weather check')
+
+    const messages = await getMessages(page)
+    const assistantMessage = messages[1]
+
+    const toolCallPart = assistantMessage.parts.find(
+      (p: any) => p.type === 'tool-call',
+    )
+
+    // Arguments should be a JSON string
+    expect(toolCallPart.arguments).toBeDefined()
+    const args = JSON.parse(toolCallPart.arguments)
+    expect(args.city).toBe('New York')
+  })
+})
+
+/**
+ * Chat E2E Tests - Error Handling with Mock API
+ */
+test.describe('Chat E2E Tests - Error Handling (Mock API)', () => {
+  test('should handle error response gracefully', async ({ page }) => {
+    await goToMockScenario(page, 'error')
+
+    // Error scenario produces user message + assistant message (with error)
+    await sendMessageAndWait(page, 'Trigger error', 2)
+
+    // The chat page should have both messages
+    const messages = await getMessages(page)
+    expect(messages.length).toBe(2)
+    expect(messages[0].role).toBe('user')
+    expect(messages[1].role).toBe('assistant')
+
+    // Verify error state is set
+    const chatPage = page.locator('[data-testid="chat-page"]')
+    await expect(chatPage).toHaveAttribute('data-has-error', 'true')
+  })
+})
+
+// Take screenshot on failure for debugging
+test.afterEach(async ({ page }, testInfo) => {
+  if (testInfo.status !== testInfo.expectedStatus) {
+    await page.screenshot({
+      path: `test-results/failure-${testInfo.title.replace(/\s+/g, '-')}.png`,
+      fullPage: true,
+    })
+  }
+})
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index bac95717..9510accf 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1241,6 +1241,9 @@ importers:
       '@tanstack/ai-openai':
         specifier: workspace:*
         version: link:../../packages/typescript/ai-openai
+      '@tanstack/ai-openrouter':
+        specifier: workspace:*
+        version: link:../../packages/typescript/ai-openrouter
       '@tanstack/ai-react':
         specifier: workspace:*
         version: link:../../packages/typescript/ai-react
@@ -1296,6 +1299,9 @@ importers:
         specifier: ^4.2.0
         version: 4.2.1
     devDependencies:
+      '@playwright/test':
+        specifier: ^1.57.0
+        version: 1.57.0
       '@types/node':
         specifier: ^24.10.1
         version: 24.10.3
@@ -1308,6 +1314,9 @@ importers:
       '@vitejs/plugin-react':
         specifier: ^5.1.2
         version: 5.1.2(vite@7.2.7(@types/node@24.10.3)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.2))
+      dotenv:
+        specifier: ^17.2.3
+        version: 17.2.3
       typescript:
         specifier: 5.9.3
         version: 5.9.3
@@ -12646,7 +12655,7 @@ snapshots:
 
   dotenv-expand@11.0.7:
     dependencies:
-      dotenv: 16.4.7
+      dotenv: 16.6.1
 
   dotenv@16.4.7: {}
 
diff --git a/scripts/distribute-keys.ts b/scripts/distribute-keys.ts
new file mode 100644
index 00000000..08c4735e
--- /dev/null
+++ b/scripts/distribute-keys.ts
@@ -0,0 +1,173 @@
+#!/usr/bin/env tsx
+/**
+ * Distribute API keys from a source file to all .env and .env.local files in the project.
+ *
+ * Usage: pnpm tsx scripts/distribute-keys.ts <source-file>
+ *
+ * Example: pnpm tsx scripts/distribute-keys.ts ~/keys.env
+ *
+ * The source file should contain KEY=value pairs, one per line.
+ * Keys from the source file will be added/updated in all target env files.
+ * Existing keys not in the source file will be preserved.
+ */
+
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+// Static paths for .env.local files
+const STATIC_ENV_LOCAL_PATHS = [
+  'testing/panel/.env.local',
+  'packages/typescript/smoke-tests/e2e/.env.local',
+  'packages/typescript/smoke-tests/adapters/.env.local',
+  'packages/typescript/ai-code-mode/.env.local',
+  'packages/typescript/ai-anthropic/live-tests/.env.local',
+  'packages/typescript/ai-openai/live-tests/.env.local',
+]
+
+/**
+ * Dynamically find all .env and .env.local files in the examples directory
+ */
+function findExampleEnvFiles(projectRoot: string): string[] {
+  const examplesDir = path.join(projectRoot, 'examples')
+  if (!fs.existsSync(examplesDir)) return []
+
+  const envFiles: string[] = []
+  const examples = fs.readdirSync(examplesDir, { withFileTypes: true })
+
+  for (const entry of examples) {
+    if (!entry.isDirectory()) continue
+
+    const exampleDir = path.join(examplesDir, entry.name)
+
+    // Check for .env.local
+    const envLocalPath = path.join(exampleDir, '.env.local')
+    if (fs.existsSync(envLocalPath)) {
+      envFiles.push(`examples/${entry.name}/.env.local`)
+    }
+
+    // Check for .env
+    const envPath = path.join(exampleDir, '.env')
+    if (fs.existsSync(envPath)) {
+      envFiles.push(`examples/${entry.name}/.env`)
+    }
+  }
+
+  return envFiles
+}
+
+function parseEnvFile(content: string): Map<string, string> {
+  const entries = new Map<string, string>()
+  const lines = content.split('\n')
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+    // Skip empty lines and comments
+    if (!trimmed || trimmed.startsWith('#')) continue
+
+    const eqIndex = trimmed.indexOf('=')
+    if (eqIndex > 0) {
+      const key = trimmed.slice(0, eqIndex).trim()
+      const value = trimmed.slice(eqIndex + 1).trim()
+      entries.set(key, value)
+    }
+  }
+
+  return entries
+}
+
+function serializeEnvFile(entries: Map<string, string>): string {
+  const lines: string[] = []
+  for (const [key, value] of entries) {
+    lines.push(`${key}=${value}`)
+  }
+  return lines.join('\n') + '\n'
+}
+
+function main() {
+  const args = process.argv.slice(2)
+
+  if (args.length === 0) {
+    console.error('Usage: pnpm tsx scripts/distribute-keys.ts <source-file>')
+    console.error('')
+    console.error('Example: pnpm tsx scripts/distribute-keys.ts ~/keys.env')
+    process.exit(1)
+  }
+
+  const sourceFile = args[0]!
+  const resolvedSource = path.resolve(sourceFile)
+
+  if (!fs.existsSync(resolvedSource)) {
+    console.error(`Error: Source file not found: ${resolvedSource}`)
+    process.exit(1)
+  }
+
+  // Read source keys
+  const sourceContent = fs.readFileSync(resolvedSource, 'utf-8')
+  const sourceKeys = parseEnvFile(sourceContent)
+
+  if (sourceKeys.size === 0) {
+    console.error('Error: No keys found in source file')
+    process.exit(1)
+  }
+
+  const projectRoot = path.resolve(import.meta.dirname, '..')
+
+  // Combine static paths with dynamically found example env files
+  const exampleEnvFiles = findExampleEnvFiles(projectRoot)
+  const allEnvPaths = [...STATIC_ENV_LOCAL_PATHS, ...exampleEnvFiles]
+
+  console.log(`📦 Distributing ${sourceKeys.size} key(s) from ${sourceFile}`)
+  console.log(`   Keys: ${Array.from(sourceKeys.keys()).join(', ')}`)
+  console.log(`   Target files: ${allEnvPaths.length}`)
+  console.log('')
+
+  let updated = 0
+  let created = 0
+  let skipped = 0
+
+  for (const relativePath of allEnvPaths) {
+    const fullPath = path.join(projectRoot, relativePath)
+    const dirPath = path.dirname(fullPath)
+
+    // Skip if directory doesn't exist
+    if (!fs.existsSync(dirPath)) {
+      console.log(`⏭️  Skipped (dir not found): ${relativePath}`)
+      skipped++
+      continue
+    }
+
+    // Read existing file or start fresh
+    let existingKeys = new Map<string, string>()
+    const fileExists = fs.existsSync(fullPath)
+
+    if (fileExists) {
+      const existingContent = fs.readFileSync(fullPath, 'utf-8')
+      existingKeys = parseEnvFile(existingContent)
+    }
+
+    // Merge: source keys override existing keys
+    const mergedKeys = new Map(existingKeys)
+    for (const [key, value] of sourceKeys) {
+      mergedKeys.set(key, value)
+    }
+
+    // Write the merged content
+    const newContent = serializeEnvFile(mergedKeys)
+    fs.writeFileSync(fullPath, newContent)
+
+    if (fileExists) {
+      console.log(`✅ Updated: ${relativePath}`)
+      updated++
+    } else {
+      console.log(`🆕 Created: ${relativePath}`)
+      created++
+    }
+  }
+
+  console.log('')
+  console.log(
+    `Done! Updated: ${updated}, Created: ${created}, Skipped: ${skipped}`,
+  )
+}
+
+main()
diff --git a/testing/panel/package.json b/testing/panel/package.json
index f5d6863c..68820780 100644
--- a/testing/panel/package.json
+++ b/testing/panel/package.json
@@ -5,7 +5,9 @@
   "scripts": {
     "dev": "vite dev --port 3010",
     "build": "vite build",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test:e2e": "playwright test",
+    "test:e2e:ui": "playwright test --ui"
   },
   "dependencies": {
     "@tailwindcss/vite": "^4.1.18",
@@ -16,6 +18,7 @@
     "@tanstack/ai-grok": "workspace:*",
     "@tanstack/ai-ollama": "workspace:*",
     "@tanstack/ai-openai": "workspace:*",
+    "@tanstack/ai-openrouter": "workspace:*",
     "@tanstack/ai-react": "workspace:*",
     "@tanstack/ai-react-ui": "workspace:*",
     "@tanstack/nitro-v2-vite-plugin": "^1.141.0",
@@ -36,10 +39,12 @@
     "zod": "^4.2.0"
   },
   "devDependencies": {
+    "@playwright/test": "^1.57.0",
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^5.1.2",
+    "dotenv": "^17.2.3",
     "typescript": "5.9.3",
     "vite": "^7.2.7"
   }
diff --git a/testing/panel/playwright-report/index.html b/testing/panel/playwright-report/index.html
new file mode 100644
index 00000000..39bd82c0
--- /dev/null
+++ b/testing/panel/playwright-report/index.html
@@ -0,0 +1,23430 @@
+<!doctype html>
+<html style="scrollbar-gutter: stable both-edges">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="color-scheme" content="dark light" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Playwright Test Report</title>
+    <script type="module">
+      var oA = Object.defineProperty
+      var dA = (u, i, c) =>
+        i in u
+          ? oA(u, i, {
+              enumerable: !0,
+              configurable: !0,
+              writable: !0,
+              value: c,
+            })
+          : (u[i] = c)
+      var dn = (u, i, c) => dA(u, typeof i != 'symbol' ? i + '' : i, c)
+      ;(function () {
+        const i = document.createElement('link').relList
+        if (i && i.supports && i.supports('modulepreload')) return
+        for (const r of document.querySelectorAll('link[rel="modulepreload"]'))
+          f(r)
+        new MutationObserver((r) => {
+          for (const o of r)
+            if (o.type === 'childList')
+              for (const d of o.addedNodes)
+                d.tagName === 'LINK' && d.rel === 'modulepreload' && f(d)
+        }).observe(document, { childList: !0, subtree: !0 })
+        function c(r) {
+          const o = {}
+          return (
+            r.integrity && (o.integrity = r.integrity),
+            r.referrerPolicy && (o.referrerPolicy = r.referrerPolicy),
+            r.crossOrigin === 'use-credentials'
+              ? (o.credentials = 'include')
+              : r.crossOrigin === 'anonymous'
+                ? (o.credentials = 'omit')
+                : (o.credentials = 'same-origin'),
+            o
+          )
+        }
+        function f(r) {
+          if (r.ep) return
+          r.ep = !0
+          const o = c(r)
+          fetch(r.href, o)
+        }
+      })()
+      function hA(u) {
+        return u &&
+          u.__esModule &&
+          Object.prototype.hasOwnProperty.call(u, 'default')
+          ? u.default
+          : u
+      }
+      var pf = { exports: {} },
+        Ai = {}
+      /**
+       * @license React
+       * react-jsx-runtime.production.js
+       *
+       * Copyright (c) Meta Platforms, Inc. and affiliates.
+       *
+       * This source code is licensed under the MIT license found in the
+       * LICENSE file in the root directory of this source tree.
+       */ var d1
+      function gA() {
+        if (d1) return Ai
+        d1 = 1
+        var u = Symbol.for('react.transitional.element'),
+          i = Symbol.for('react.fragment')
+        function c(f, r, o) {
+          var d = null
+          if (
+            (o !== void 0 && (d = '' + o),
+            r.key !== void 0 && (d = '' + r.key),
+            'key' in r)
+          ) {
+            o = {}
+            for (var y in r) y !== 'key' && (o[y] = r[y])
+          } else o = r
+          return (
+            (r = o.ref),
+            {
+              $$typeof: u,
+              type: f,
+              key: d,
+              ref: r !== void 0 ? r : null,
+              props: o,
+            }
+          )
+        }
+        return ((Ai.Fragment = i), (Ai.jsx = c), (Ai.jsxs = c), Ai)
+      }
+      var h1
+      function mA() {
+        return (h1 || ((h1 = 1), (pf.exports = gA())), pf.exports)
+      }
+      var m = mA()
+      const AA = 15,
+        bt = 0,
+        mn = 1,
+        vA = 2,
+        me = -2,
+        Ht = -3,
+        g1 = -4,
+        An = -5,
+        we = [
+          0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383,
+          32767, 65535,
+        ],
+        S2 = 1440,
+        yA = 0,
+        EA = 4,
+        bA = 9,
+        pA = 5,
+        xA = [
+          96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0,
+          8, 48, 0, 9, 192, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 160, 0, 8, 0,
+          0, 8, 128, 0, 8, 64, 0, 9, 224, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9,
+          144, 83, 7, 59, 0, 8, 120, 0, 8, 56, 0, 9, 208, 81, 7, 17, 0, 8, 104,
+          0, 8, 40, 0, 9, 176, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 240, 80, 7,
+          4, 0, 8, 84, 0, 8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0,
+          9, 200, 81, 7, 13, 0, 8, 100, 0, 8, 36, 0, 9, 168, 0, 8, 4, 0, 8, 132,
+          0, 8, 68, 0, 9, 232, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 152, 84, 7,
+          83, 0, 8, 124, 0, 8, 60, 0, 9, 216, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0,
+          9, 184, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, 248, 80, 7, 3, 0, 8, 82,
+          0, 8, 18, 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 196, 81,
+          7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 164, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0,
+          9, 228, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 148, 84, 7, 67, 0, 8, 122,
+          0, 8, 58, 0, 9, 212, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 180, 0, 8,
+          10, 0, 8, 138, 0, 8, 74, 0, 9, 244, 80, 7, 5, 0, 8, 86, 0, 8, 22, 192,
+          8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 204, 81, 7, 15, 0, 8, 102,
+          0, 8, 38, 0, 9, 172, 0, 8, 6, 0, 8, 134, 0, 8, 70, 0, 9, 236, 80, 7,
+          9, 0, 8, 94, 0, 8, 30, 0, 9, 156, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0,
+          9, 220, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 188, 0, 8, 14, 0, 8,
+          142, 0, 8, 78, 0, 9, 252, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131,
+          82, 7, 31, 0, 8, 113, 0, 8, 49, 0, 9, 194, 80, 7, 10, 0, 8, 97, 0, 8,
+          33, 0, 9, 162, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 226, 80, 7, 6, 0,
+          8, 89, 0, 8, 25, 0, 9, 146, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 210,
+          81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 178, 0, 8, 9, 0, 8, 137, 0, 8,
+          73, 0, 9, 242, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0,
+          8, 117, 0, 8, 53, 0, 9, 202, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9,
+          170, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 234, 80, 7, 8, 0, 8, 93, 0,
+          8, 29, 0, 9, 154, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 218, 82, 7,
+          23, 0, 8, 109, 0, 8, 45, 0, 9, 186, 0, 8, 13, 0, 8, 141, 0, 8, 77, 0,
+          9, 250, 80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8,
+          115, 0, 8, 51, 0, 9, 198, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 166, 0,
+          8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 230, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0,
+          9, 150, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 214, 82, 7, 19, 0, 8,
+          107, 0, 8, 43, 0, 9, 182, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 246,
+          80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8,
+          55, 0, 9, 206, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 174, 0, 8, 7, 0,
+          8, 135, 0, 8, 71, 0, 9, 238, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 158,
+          84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 222, 82, 7, 27, 0, 8, 111, 0, 8,
+          47, 0, 9, 190, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 254, 96, 7, 256,
+          0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9,
+          193, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 161, 0, 8, 0, 0, 8, 128, 0,
+          8, 64, 0, 9, 225, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 145, 83, 7, 59,
+          0, 8, 120, 0, 8, 56, 0, 9, 209, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, 9,
+          177, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 241, 80, 7, 4, 0, 8, 84, 0,
+          8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 201, 81, 7,
+          13, 0, 8, 100, 0, 8, 36, 0, 9, 169, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0,
+          9, 233, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 153, 84, 7, 83, 0, 8, 124,
+          0, 8, 60, 0, 9, 217, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 185, 0, 8,
+          12, 0, 8, 140, 0, 8, 76, 0, 9, 249, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85,
+          8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 197, 81, 7, 11, 0, 8,
+          98, 0, 8, 34, 0, 9, 165, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0, 9, 229, 80,
+          7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 149, 84, 7, 67, 0, 8, 122, 0, 8, 58,
+          0, 9, 213, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 181, 0, 8, 10, 0, 8,
+          138, 0, 8, 74, 0, 9, 245, 80, 7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83,
+          7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 205, 81, 7, 15, 0, 8, 102, 0, 8, 38,
+          0, 9, 173, 0, 8, 6, 0, 8, 134, 0, 8, 70, 0, 9, 237, 80, 7, 9, 0, 8,
+          94, 0, 8, 30, 0, 9, 157, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, 221,
+          82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 189, 0, 8, 14, 0, 8, 142, 0, 8,
+          78, 0, 9, 253, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31,
+          0, 8, 113, 0, 8, 49, 0, 9, 195, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9,
+          163, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 227, 80, 7, 6, 0, 8, 89, 0,
+          8, 25, 0, 9, 147, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 211, 81, 7,
+          17, 0, 8, 105, 0, 8, 41, 0, 9, 179, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0,
+          9, 243, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8,
+          117, 0, 8, 53, 0, 9, 203, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 171,
+          0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 235, 80, 7, 8, 0, 8, 93, 0, 8, 29,
+          0, 9, 155, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 219, 82, 7, 23, 0, 8,
+          109, 0, 8, 45, 0, 9, 187, 0, 8, 13, 0, 8, 141, 0, 8, 77, 0, 9, 251,
+          80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8,
+          51, 0, 9, 199, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 167, 0, 8, 3, 0,
+          8, 131, 0, 8, 67, 0, 9, 231, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 151,
+          84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 215, 82, 7, 19, 0, 8, 107, 0, 8,
+          43, 0, 9, 183, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 247, 80, 7, 5, 0,
+          8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9, 207,
+          81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 175, 0, 8, 7, 0, 8, 135, 0, 8,
+          71, 0, 9, 239, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 159, 84, 7, 99, 0,
+          8, 127, 0, 8, 63, 0, 9, 223, 82, 7, 27, 0, 8, 111, 0, 8, 47, 0, 9,
+          191, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 255,
+        ],
+        SA = [
+          80, 5, 1, 87, 5, 257, 83, 5, 17, 91, 5, 4097, 81, 5, 5, 89, 5, 1025,
+          85, 5, 65, 93, 5, 16385, 80, 5, 3, 88, 5, 513, 84, 5, 33, 92, 5, 8193,
+          82, 5, 9, 90, 5, 2049, 86, 5, 129, 192, 5, 24577, 80, 5, 2, 87, 5,
+          385, 83, 5, 25, 91, 5, 6145, 81, 5, 7, 89, 5, 1537, 85, 5, 97, 93, 5,
+          24577, 80, 5, 4, 88, 5, 769, 84, 5, 49, 92, 5, 12289, 82, 5, 13, 90,
+          5, 3073, 86, 5, 193, 192, 5, 24577,
+        ],
+        TA = [
+          3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51,
+          59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0,
+        ],
+        wA = [
+          0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,
+          4, 5, 5, 5, 5, 0, 112, 112,
+        ],
+        RA = [
+          1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385,
+          513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385,
+          24577,
+        ],
+        OA = [
+          0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10,
+          10, 11, 11, 12, 12, 13, 13,
+        ],
+        qn = 15
+      function Xf() {
+        const u = this
+        let i, c, f, r, o, d
+        function y(A, E, w, R, z, N, x, p, T, D, U) {
+          let I, V, j, G, L, W, F, K, et, tt, ot, at, M, _, $
+          ;((tt = 0), (L = w))
+          do (f[A[E + tt]]++, tt++, L--)
+          while (L !== 0)
+          if (f[0] == w) return ((x[0] = -1), (p[0] = 0), bt)
+          for (K = p[0], W = 1; W <= qn && f[W] === 0; W++);
+          for (F = W, K < W && (K = W), L = qn; L !== 0 && f[L] === 0; L--);
+          for (
+            j = L, K > L && (K = L), p[0] = K, _ = 1 << W;
+            W < L;
+            W++, _ <<= 1
+          )
+            if ((_ -= f[W]) < 0) return Ht
+          if ((_ -= f[L]) < 0) return Ht
+          for (f[L] += _, d[1] = W = 0, tt = 1, M = 2; --L !== 0; )
+            ((d[M] = W += f[tt]), M++, tt++)
+          ;((L = 0), (tt = 0))
+          do ((W = A[E + tt]) !== 0 && (U[d[W]++] = L), tt++)
+          while (++L < w)
+          for (
+            w = d[j],
+              d[0] = L = 0,
+              tt = 0,
+              G = -1,
+              at = -K,
+              o[0] = 0,
+              ot = 0,
+              $ = 0;
+            F <= j;
+            F++
+          )
+            for (I = f[F]; I-- !== 0; ) {
+              for (; F > at + K; ) {
+                if (
+                  (G++,
+                  (at += K),
+                  ($ = j - at),
+                  ($ = $ > K ? K : $),
+                  (V = 1 << (W = F - at)) > I + 1 &&
+                    ((V -= I + 1), (M = F), W < $))
+                )
+                  for (; ++W < $ && !((V <<= 1) <= f[++M]); ) V -= f[M]
+                if ((($ = 1 << W), D[0] + $ > S2)) return Ht
+                ;((o[G] = ot = D[0]),
+                  (D[0] += $),
+                  G !== 0
+                    ? ((d[G] = L),
+                      (r[0] = W),
+                      (r[1] = K),
+                      (W = L >>> (at - K)),
+                      (r[2] = ot - o[G - 1] - W),
+                      T.set(r, (o[G - 1] + W) * 3))
+                    : (x[0] = ot))
+              }
+              for (
+                r[1] = F - at,
+                  tt >= w
+                    ? (r[0] = 192)
+                    : U[tt] < R
+                      ? ((r[0] = U[tt] < 256 ? 0 : 96), (r[2] = U[tt++]))
+                      : ((r[0] = N[U[tt] - R] + 16 + 64),
+                        (r[2] = z[U[tt++] - R])),
+                  V = 1 << (F - at),
+                  W = L >>> at;
+                W < $;
+                W += V
+              )
+                T.set(r, (ot + W) * 3)
+              for (W = 1 << (F - 1); (L & W) !== 0; W >>>= 1) L ^= W
+              for (L ^= W, et = (1 << at) - 1; (L & et) != d[G]; )
+                (G--, (at -= K), (et = (1 << at) - 1))
+            }
+          return _ !== 0 && j != 1 ? An : bt
+        }
+        function v(A) {
+          let E
+          for (
+            i ||
+              ((i = []),
+              (c = []),
+              (f = new Int32Array(qn + 1)),
+              (r = []),
+              (o = new Int32Array(qn)),
+              (d = new Int32Array(qn + 1))),
+              c.length < A && (c = []),
+              E = 0;
+            E < A;
+            E++
+          )
+            c[E] = 0
+          for (E = 0; E < qn + 1; E++) f[E] = 0
+          for (E = 0; E < 3; E++) r[E] = 0
+          ;(o.set(f.subarray(0, qn), 0), d.set(f.subarray(0, qn + 1), 0))
+        }
+        ;((u.inflate_trees_bits = function (A, E, w, R, z) {
+          let N
+          return (
+            v(19),
+            (i[0] = 0),
+            (N = y(A, 0, 19, 19, null, null, w, E, R, i, c)),
+            N == Ht
+              ? (z.msg = 'oversubscribed dynamic bit lengths tree')
+              : (N == An || E[0] === 0) &&
+                ((z.msg = 'incomplete dynamic bit lengths tree'), (N = Ht)),
+            N
+          )
+        }),
+          (u.inflate_trees_dynamic = function (A, E, w, R, z, N, x, p, T) {
+            let D
+            return (
+              v(288),
+              (i[0] = 0),
+              (D = y(w, 0, A, 257, TA, wA, N, R, p, i, c)),
+              D != bt || R[0] === 0
+                ? (D == Ht
+                    ? (T.msg = 'oversubscribed literal/length tree')
+                    : D != g1 &&
+                      ((T.msg = 'incomplete literal/length tree'), (D = Ht)),
+                  D)
+                : (v(288),
+                  (D = y(w, A, E, 0, RA, OA, x, z, p, i, c)),
+                  D != bt || (z[0] === 0 && A > 257)
+                    ? (D == Ht
+                        ? (T.msg = 'oversubscribed distance tree')
+                        : D == An
+                          ? ((T.msg = 'incomplete distance tree'), (D = Ht))
+                          : D != g1 &&
+                            ((T.msg = 'empty distance tree with lengths'),
+                            (D = Ht)),
+                      D)
+                    : bt)
+            )
+          }))
+      }
+      Xf.inflate_trees_fixed = function (u, i, c, f) {
+        return ((u[0] = bA), (i[0] = pA), (c[0] = xA), (f[0] = SA), bt)
+      }
+      const ku = 0,
+        m1 = 1,
+        A1 = 2,
+        v1 = 3,
+        y1 = 4,
+        E1 = 5,
+        b1 = 6,
+        xf = 7,
+        p1 = 8,
+        Ku = 9
+      function DA() {
+        const u = this
+        let i,
+          c = 0,
+          f,
+          r = 0,
+          o = 0,
+          d = 0,
+          y = 0,
+          v = 0,
+          A = 0,
+          E = 0,
+          w,
+          R = 0,
+          z,
+          N = 0
+        function x(p, T, D, U, I, V, j, G) {
+          let L, W, F, K, et, tt, ot, at, M, _, $, dt, b, q, P, J
+          ;((ot = G.next_in_index),
+            (at = G.avail_in),
+            (et = j.bitb),
+            (tt = j.bitk),
+            (M = j.write),
+            (_ = M < j.read ? j.read - M - 1 : j.end - M),
+            ($ = we[p]),
+            (dt = we[T]))
+          do {
+            for (; tt < 20; )
+              (at--, (et |= (G.read_byte(ot++) & 255) << tt), (tt += 8))
+            if (
+              ((L = et & $),
+              (W = D),
+              (F = U),
+              (J = (F + L) * 3),
+              (K = W[J]) === 0)
+            ) {
+              ;((et >>= W[J + 1]),
+                (tt -= W[J + 1]),
+                (j.win[M++] = W[J + 2]),
+                _--)
+              continue
+            }
+            do {
+              if (((et >>= W[J + 1]), (tt -= W[J + 1]), (K & 16) !== 0)) {
+                for (
+                  K &= 15, b = W[J + 2] + (et & we[K]), et >>= K, tt -= K;
+                  tt < 15;
+                )
+                  (at--, (et |= (G.read_byte(ot++) & 255) << tt), (tt += 8))
+                ;((L = et & dt),
+                  (W = I),
+                  (F = V),
+                  (J = (F + L) * 3),
+                  (K = W[J]))
+                do
+                  if (((et >>= W[J + 1]), (tt -= W[J + 1]), (K & 16) !== 0)) {
+                    for (K &= 15; tt < K; )
+                      (at--, (et |= (G.read_byte(ot++) & 255) << tt), (tt += 8))
+                    if (
+                      ((q = W[J + 2] + (et & we[K])),
+                      (et >>= K),
+                      (tt -= K),
+                      (_ -= b),
+                      M >= q)
+                    )
+                      ((P = M - q),
+                        M - P > 0 && 2 > M - P
+                          ? ((j.win[M++] = j.win[P++]),
+                            (j.win[M++] = j.win[P++]),
+                            (b -= 2))
+                          : (j.win.set(j.win.subarray(P, P + 2), M),
+                            (M += 2),
+                            (P += 2),
+                            (b -= 2)))
+                    else {
+                      P = M - q
+                      do P += j.end
+                      while (P < 0)
+                      if (((K = j.end - P), b > K)) {
+                        if (((b -= K), M - P > 0 && K > M - P))
+                          do j.win[M++] = j.win[P++]
+                          while (--K !== 0)
+                        else
+                          (j.win.set(j.win.subarray(P, P + K), M),
+                            (M += K),
+                            (P += K),
+                            (K = 0))
+                        P = 0
+                      }
+                    }
+                    if (M - P > 0 && b > M - P)
+                      do j.win[M++] = j.win[P++]
+                      while (--b !== 0)
+                    else
+                      (j.win.set(j.win.subarray(P, P + b), M),
+                        (M += b),
+                        (P += b),
+                        (b = 0))
+                    break
+                  } else if ((K & 64) === 0)
+                    ((L += W[J + 2]),
+                      (L += et & we[K]),
+                      (J = (F + L) * 3),
+                      (K = W[J]))
+                  else
+                    return (
+                      (G.msg = 'invalid distance code'),
+                      (b = G.avail_in - at),
+                      (b = tt >> 3 < b ? tt >> 3 : b),
+                      (at += b),
+                      (ot -= b),
+                      (tt -= b << 3),
+                      (j.bitb = et),
+                      (j.bitk = tt),
+                      (G.avail_in = at),
+                      (G.total_in += ot - G.next_in_index),
+                      (G.next_in_index = ot),
+                      (j.write = M),
+                      Ht
+                    )
+                while (!0)
+                break
+              }
+              if ((K & 64) === 0) {
+                if (
+                  ((L += W[J + 2]),
+                  (L += et & we[K]),
+                  (J = (F + L) * 3),
+                  (K = W[J]) === 0)
+                ) {
+                  ;((et >>= W[J + 1]),
+                    (tt -= W[J + 1]),
+                    (j.win[M++] = W[J + 2]),
+                    _--)
+                  break
+                }
+              } else
+                return (K & 32) !== 0
+                  ? ((b = G.avail_in - at),
+                    (b = tt >> 3 < b ? tt >> 3 : b),
+                    (at += b),
+                    (ot -= b),
+                    (tt -= b << 3),
+                    (j.bitb = et),
+                    (j.bitk = tt),
+                    (G.avail_in = at),
+                    (G.total_in += ot - G.next_in_index),
+                    (G.next_in_index = ot),
+                    (j.write = M),
+                    mn)
+                  : ((G.msg = 'invalid literal/length code'),
+                    (b = G.avail_in - at),
+                    (b = tt >> 3 < b ? tt >> 3 : b),
+                    (at += b),
+                    (ot -= b),
+                    (tt -= b << 3),
+                    (j.bitb = et),
+                    (j.bitk = tt),
+                    (G.avail_in = at),
+                    (G.total_in += ot - G.next_in_index),
+                    (G.next_in_index = ot),
+                    (j.write = M),
+                    Ht)
+            } while (!0)
+          } while (_ >= 258 && at >= 10)
+          return (
+            (b = G.avail_in - at),
+            (b = tt >> 3 < b ? tt >> 3 : b),
+            (at += b),
+            (ot -= b),
+            (tt -= b << 3),
+            (j.bitb = et),
+            (j.bitk = tt),
+            (G.avail_in = at),
+            (G.total_in += ot - G.next_in_index),
+            (G.next_in_index = ot),
+            (j.write = M),
+            bt
+          )
+        }
+        ;((u.init = function (p, T, D, U, I, V) {
+          ;((i = ku),
+            (A = p),
+            (E = T),
+            (w = D),
+            (R = U),
+            (z = I),
+            (N = V),
+            (f = null))
+        }),
+          (u.proc = function (p, T, D) {
+            let U,
+              I,
+              V,
+              j = 0,
+              G = 0,
+              L = 0,
+              W,
+              F,
+              K,
+              et
+            for (
+              L = T.next_in_index,
+                W = T.avail_in,
+                j = p.bitb,
+                G = p.bitk,
+                F = p.write,
+                K = F < p.read ? p.read - F - 1 : p.end - F;
+              ;
+            )
+              switch (i) {
+                case ku:
+                  if (
+                    K >= 258 &&
+                    W >= 10 &&
+                    ((p.bitb = j),
+                    (p.bitk = G),
+                    (T.avail_in = W),
+                    (T.total_in += L - T.next_in_index),
+                    (T.next_in_index = L),
+                    (p.write = F),
+                    (D = x(A, E, w, R, z, N, p, T)),
+                    (L = T.next_in_index),
+                    (W = T.avail_in),
+                    (j = p.bitb),
+                    (G = p.bitk),
+                    (F = p.write),
+                    (K = F < p.read ? p.read - F - 1 : p.end - F),
+                    D != bt)
+                  ) {
+                    i = D == mn ? xf : Ku
+                    break
+                  }
+                  ;((o = A), (f = w), (r = R), (i = m1))
+                case m1:
+                  for (U = o; G < U; ) {
+                    if (W !== 0) D = bt
+                    else
+                      return (
+                        (p.bitb = j),
+                        (p.bitk = G),
+                        (T.avail_in = W),
+                        (T.total_in += L - T.next_in_index),
+                        (T.next_in_index = L),
+                        (p.write = F),
+                        p.inflate_flush(T, D)
+                      )
+                    ;(W--, (j |= (T.read_byte(L++) & 255) << G), (G += 8))
+                  }
+                  if (
+                    ((I = (r + (j & we[U])) * 3),
+                    (j >>>= f[I + 1]),
+                    (G -= f[I + 1]),
+                    (V = f[I]),
+                    V === 0)
+                  ) {
+                    ;((d = f[I + 2]), (i = b1))
+                    break
+                  }
+                  if ((V & 16) !== 0) {
+                    ;((y = V & 15), (c = f[I + 2]), (i = A1))
+                    break
+                  }
+                  if ((V & 64) === 0) {
+                    ;((o = V), (r = I / 3 + f[I + 2]))
+                    break
+                  }
+                  if ((V & 32) !== 0) {
+                    i = xf
+                    break
+                  }
+                  return (
+                    (i = Ku),
+                    (T.msg = 'invalid literal/length code'),
+                    (D = Ht),
+                    (p.bitb = j),
+                    (p.bitk = G),
+                    (T.avail_in = W),
+                    (T.total_in += L - T.next_in_index),
+                    (T.next_in_index = L),
+                    (p.write = F),
+                    p.inflate_flush(T, D)
+                  )
+                case A1:
+                  for (U = y; G < U; ) {
+                    if (W !== 0) D = bt
+                    else
+                      return (
+                        (p.bitb = j),
+                        (p.bitk = G),
+                        (T.avail_in = W),
+                        (T.total_in += L - T.next_in_index),
+                        (T.next_in_index = L),
+                        (p.write = F),
+                        p.inflate_flush(T, D)
+                      )
+                    ;(W--, (j |= (T.read_byte(L++) & 255) << G), (G += 8))
+                  }
+                  ;((c += j & we[U]),
+                    (j >>= U),
+                    (G -= U),
+                    (o = E),
+                    (f = z),
+                    (r = N),
+                    (i = v1))
+                case v1:
+                  for (U = o; G < U; ) {
+                    if (W !== 0) D = bt
+                    else
+                      return (
+                        (p.bitb = j),
+                        (p.bitk = G),
+                        (T.avail_in = W),
+                        (T.total_in += L - T.next_in_index),
+                        (T.next_in_index = L),
+                        (p.write = F),
+                        p.inflate_flush(T, D)
+                      )
+                    ;(W--, (j |= (T.read_byte(L++) & 255) << G), (G += 8))
+                  }
+                  if (
+                    ((I = (r + (j & we[U])) * 3),
+                    (j >>= f[I + 1]),
+                    (G -= f[I + 1]),
+                    (V = f[I]),
+                    (V & 16) !== 0)
+                  ) {
+                    ;((y = V & 15), (v = f[I + 2]), (i = y1))
+                    break
+                  }
+                  if ((V & 64) === 0) {
+                    ;((o = V), (r = I / 3 + f[I + 2]))
+                    break
+                  }
+                  return (
+                    (i = Ku),
+                    (T.msg = 'invalid distance code'),
+                    (D = Ht),
+                    (p.bitb = j),
+                    (p.bitk = G),
+                    (T.avail_in = W),
+                    (T.total_in += L - T.next_in_index),
+                    (T.next_in_index = L),
+                    (p.write = F),
+                    p.inflate_flush(T, D)
+                  )
+                case y1:
+                  for (U = y; G < U; ) {
+                    if (W !== 0) D = bt
+                    else
+                      return (
+                        (p.bitb = j),
+                        (p.bitk = G),
+                        (T.avail_in = W),
+                        (T.total_in += L - T.next_in_index),
+                        (T.next_in_index = L),
+                        (p.write = F),
+                        p.inflate_flush(T, D)
+                      )
+                    ;(W--, (j |= (T.read_byte(L++) & 255) << G), (G += 8))
+                  }
+                  ;((v += j & we[U]), (j >>= U), (G -= U), (i = E1))
+                case E1:
+                  for (et = F - v; et < 0; ) et += p.end
+                  for (; c !== 0; ) {
+                    if (
+                      K === 0 &&
+                      (F == p.end &&
+                        p.read !== 0 &&
+                        ((F = 0),
+                        (K = F < p.read ? p.read - F - 1 : p.end - F)),
+                      K === 0 &&
+                        ((p.write = F),
+                        (D = p.inflate_flush(T, D)),
+                        (F = p.write),
+                        (K = F < p.read ? p.read - F - 1 : p.end - F),
+                        F == p.end &&
+                          p.read !== 0 &&
+                          ((F = 0),
+                          (K = F < p.read ? p.read - F - 1 : p.end - F)),
+                        K === 0))
+                    )
+                      return (
+                        (p.bitb = j),
+                        (p.bitk = G),
+                        (T.avail_in = W),
+                        (T.total_in += L - T.next_in_index),
+                        (T.next_in_index = L),
+                        (p.write = F),
+                        p.inflate_flush(T, D)
+                      )
+                    ;((p.win[F++] = p.win[et++]),
+                      K--,
+                      et == p.end && (et = 0),
+                      c--)
+                  }
+                  i = ku
+                  break
+                case b1:
+                  if (
+                    K === 0 &&
+                    (F == p.end &&
+                      p.read !== 0 &&
+                      ((F = 0), (K = F < p.read ? p.read - F - 1 : p.end - F)),
+                    K === 0 &&
+                      ((p.write = F),
+                      (D = p.inflate_flush(T, D)),
+                      (F = p.write),
+                      (K = F < p.read ? p.read - F - 1 : p.end - F),
+                      F == p.end &&
+                        p.read !== 0 &&
+                        ((F = 0),
+                        (K = F < p.read ? p.read - F - 1 : p.end - F)),
+                      K === 0))
+                  )
+                    return (
+                      (p.bitb = j),
+                      (p.bitk = G),
+                      (T.avail_in = W),
+                      (T.total_in += L - T.next_in_index),
+                      (T.next_in_index = L),
+                      (p.write = F),
+                      p.inflate_flush(T, D)
+                    )
+                  ;((D = bt), (p.win[F++] = d), K--, (i = ku))
+                  break
+                case xf:
+                  if (
+                    (G > 7 && ((G -= 8), W++, L--),
+                    (p.write = F),
+                    (D = p.inflate_flush(T, D)),
+                    (F = p.write),
+                    (K = F < p.read ? p.read - F - 1 : p.end - F),
+                    p.read != p.write)
+                  )
+                    return (
+                      (p.bitb = j),
+                      (p.bitk = G),
+                      (T.avail_in = W),
+                      (T.total_in += L - T.next_in_index),
+                      (T.next_in_index = L),
+                      (p.write = F),
+                      p.inflate_flush(T, D)
+                    )
+                  i = p1
+                case p1:
+                  return (
+                    (D = mn),
+                    (p.bitb = j),
+                    (p.bitk = G),
+                    (T.avail_in = W),
+                    (T.total_in += L - T.next_in_index),
+                    (T.next_in_index = L),
+                    (p.write = F),
+                    p.inflate_flush(T, D)
+                  )
+                case Ku:
+                  return (
+                    (D = Ht),
+                    (p.bitb = j),
+                    (p.bitk = G),
+                    (T.avail_in = W),
+                    (T.total_in += L - T.next_in_index),
+                    (T.next_in_index = L),
+                    (p.write = F),
+                    p.inflate_flush(T, D)
+                  )
+                default:
+                  return (
+                    (D = me),
+                    (p.bitb = j),
+                    (p.bitk = G),
+                    (T.avail_in = W),
+                    (T.total_in += L - T.next_in_index),
+                    (T.next_in_index = L),
+                    (p.write = F),
+                    p.inflate_flush(T, D)
+                  )
+              }
+          }),
+          (u.free = function () {}))
+      }
+      const x1 = [
+          16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15,
+        ],
+        hl = 0,
+        Sf = 1,
+        S1 = 2,
+        T1 = 3,
+        w1 = 4,
+        R1 = 5,
+        Wu = 6,
+        Fu = 7,
+        O1 = 8,
+        pa = 9
+      function CA(u, i) {
+        const c = this
+        let f = hl,
+          r = 0,
+          o = 0,
+          d = 0,
+          y
+        const v = [0],
+          A = [0],
+          E = new DA()
+        let w = 0,
+          R = new Int32Array(S2 * 3)
+        const z = 0,
+          N = new Xf()
+        ;((c.bitk = 0),
+          (c.bitb = 0),
+          (c.win = new Uint8Array(i)),
+          (c.end = i),
+          (c.read = 0),
+          (c.write = 0),
+          (c.reset = function (x, p) {
+            ;(p && (p[0] = z),
+              f == Wu && E.free(x),
+              (f = hl),
+              (c.bitk = 0),
+              (c.bitb = 0),
+              (c.read = c.write = 0))
+          }),
+          c.reset(u, null),
+          (c.inflate_flush = function (x, p) {
+            let T, D, U
+            return (
+              (D = x.next_out_index),
+              (U = c.read),
+              (T = (U <= c.write ? c.write : c.end) - U),
+              T > x.avail_out && (T = x.avail_out),
+              T !== 0 && p == An && (p = bt),
+              (x.avail_out -= T),
+              (x.total_out += T),
+              x.next_out.set(c.win.subarray(U, U + T), D),
+              (D += T),
+              (U += T),
+              U == c.end &&
+                ((U = 0),
+                c.write == c.end && (c.write = 0),
+                (T = c.write - U),
+                T > x.avail_out && (T = x.avail_out),
+                T !== 0 && p == An && (p = bt),
+                (x.avail_out -= T),
+                (x.total_out += T),
+                x.next_out.set(c.win.subarray(U, U + T), D),
+                (D += T),
+                (U += T)),
+              (x.next_out_index = D),
+              (c.read = U),
+              p
+            )
+          }),
+          (c.proc = function (x, p) {
+            let T, D, U, I, V, j, G, L
+            for (
+              I = x.next_in_index,
+                V = x.avail_in,
+                D = c.bitb,
+                U = c.bitk,
+                j = c.write,
+                G = j < c.read ? c.read - j - 1 : c.end - j;
+              ;
+            ) {
+              let W, F, K, et, tt, ot, at, M
+              switch (f) {
+                case hl:
+                  for (; U < 3; ) {
+                    if (V !== 0) p = bt
+                    else
+                      return (
+                        (c.bitb = D),
+                        (c.bitk = U),
+                        (x.avail_in = V),
+                        (x.total_in += I - x.next_in_index),
+                        (x.next_in_index = I),
+                        (c.write = j),
+                        c.inflate_flush(x, p)
+                      )
+                    ;(V--, (D |= (x.read_byte(I++) & 255) << U), (U += 8))
+                  }
+                  switch (((T = D & 7), (w = T & 1), T >>> 1)) {
+                    case 0:
+                      ;((D >>>= 3),
+                        (U -= 3),
+                        (T = U & 7),
+                        (D >>>= T),
+                        (U -= T),
+                        (f = Sf))
+                      break
+                    case 1:
+                      ;((W = []),
+                        (F = []),
+                        (K = [[]]),
+                        (et = [[]]),
+                        Xf.inflate_trees_fixed(W, F, K, et),
+                        E.init(W[0], F[0], K[0], 0, et[0], 0),
+                        (D >>>= 3),
+                        (U -= 3),
+                        (f = Wu))
+                      break
+                    case 2:
+                      ;((D >>>= 3), (U -= 3), (f = T1))
+                      break
+                    case 3:
+                      return (
+                        (D >>>= 3),
+                        (U -= 3),
+                        (f = pa),
+                        (x.msg = 'invalid block type'),
+                        (p = Ht),
+                        (c.bitb = D),
+                        (c.bitk = U),
+                        (x.avail_in = V),
+                        (x.total_in += I - x.next_in_index),
+                        (x.next_in_index = I),
+                        (c.write = j),
+                        c.inflate_flush(x, p)
+                      )
+                  }
+                  break
+                case Sf:
+                  for (; U < 32; ) {
+                    if (V !== 0) p = bt
+                    else
+                      return (
+                        (c.bitb = D),
+                        (c.bitk = U),
+                        (x.avail_in = V),
+                        (x.total_in += I - x.next_in_index),
+                        (x.next_in_index = I),
+                        (c.write = j),
+                        c.inflate_flush(x, p)
+                      )
+                    ;(V--, (D |= (x.read_byte(I++) & 255) << U), (U += 8))
+                  }
+                  if (((~D >>> 16) & 65535) != (D & 65535))
+                    return (
+                      (f = pa),
+                      (x.msg = 'invalid stored block lengths'),
+                      (p = Ht),
+                      (c.bitb = D),
+                      (c.bitk = U),
+                      (x.avail_in = V),
+                      (x.total_in += I - x.next_in_index),
+                      (x.next_in_index = I),
+                      (c.write = j),
+                      c.inflate_flush(x, p)
+                    )
+                  ;((r = D & 65535),
+                    (D = U = 0),
+                    (f = r !== 0 ? S1 : w !== 0 ? Fu : hl))
+                  break
+                case S1:
+                  if (
+                    V === 0 ||
+                    (G === 0 &&
+                      (j == c.end &&
+                        c.read !== 0 &&
+                        ((j = 0),
+                        (G = j < c.read ? c.read - j - 1 : c.end - j)),
+                      G === 0 &&
+                        ((c.write = j),
+                        (p = c.inflate_flush(x, p)),
+                        (j = c.write),
+                        (G = j < c.read ? c.read - j - 1 : c.end - j),
+                        j == c.end &&
+                          c.read !== 0 &&
+                          ((j = 0),
+                          (G = j < c.read ? c.read - j - 1 : c.end - j)),
+                        G === 0)))
+                  )
+                    return (
+                      (c.bitb = D),
+                      (c.bitk = U),
+                      (x.avail_in = V),
+                      (x.total_in += I - x.next_in_index),
+                      (x.next_in_index = I),
+                      (c.write = j),
+                      c.inflate_flush(x, p)
+                    )
+                  if (
+                    ((p = bt),
+                    (T = r),
+                    T > V && (T = V),
+                    T > G && (T = G),
+                    c.win.set(x.read_buf(I, T), j),
+                    (I += T),
+                    (V -= T),
+                    (j += T),
+                    (G -= T),
+                    (r -= T) !== 0)
+                  )
+                    break
+                  f = w !== 0 ? Fu : hl
+                  break
+                case T1:
+                  for (; U < 14; ) {
+                    if (V !== 0) p = bt
+                    else
+                      return (
+                        (c.bitb = D),
+                        (c.bitk = U),
+                        (x.avail_in = V),
+                        (x.total_in += I - x.next_in_index),
+                        (x.next_in_index = I),
+                        (c.write = j),
+                        c.inflate_flush(x, p)
+                      )
+                    ;(V--, (D |= (x.read_byte(I++) & 255) << U), (U += 8))
+                  }
+                  if (
+                    ((o = T = D & 16383), (T & 31) > 29 || ((T >> 5) & 31) > 29)
+                  )
+                    return (
+                      (f = pa),
+                      (x.msg = 'too many length or distance symbols'),
+                      (p = Ht),
+                      (c.bitb = D),
+                      (c.bitk = U),
+                      (x.avail_in = V),
+                      (x.total_in += I - x.next_in_index),
+                      (x.next_in_index = I),
+                      (c.write = j),
+                      c.inflate_flush(x, p)
+                    )
+                  if (
+                    ((T = 258 + (T & 31) + ((T >> 5) & 31)), !y || y.length < T)
+                  )
+                    y = []
+                  else for (L = 0; L < T; L++) y[L] = 0
+                  ;((D >>>= 14), (U -= 14), (d = 0), (f = w1))
+                case w1:
+                  for (; d < 4 + (o >>> 10); ) {
+                    for (; U < 3; ) {
+                      if (V !== 0) p = bt
+                      else
+                        return (
+                          (c.bitb = D),
+                          (c.bitk = U),
+                          (x.avail_in = V),
+                          (x.total_in += I - x.next_in_index),
+                          (x.next_in_index = I),
+                          (c.write = j),
+                          c.inflate_flush(x, p)
+                        )
+                      ;(V--, (D |= (x.read_byte(I++) & 255) << U), (U += 8))
+                    }
+                    ;((y[x1[d++]] = D & 7), (D >>>= 3), (U -= 3))
+                  }
+                  for (; d < 19; ) y[x1[d++]] = 0
+                  if (
+                    ((v[0] = 7),
+                    (T = N.inflate_trees_bits(y, v, A, R, x)),
+                    T != bt)
+                  )
+                    return (
+                      (p = T),
+                      p == Ht && ((y = null), (f = pa)),
+                      (c.bitb = D),
+                      (c.bitk = U),
+                      (x.avail_in = V),
+                      (x.total_in += I - x.next_in_index),
+                      (x.next_in_index = I),
+                      (c.write = j),
+                      c.inflate_flush(x, p)
+                    )
+                  ;((d = 0), (f = R1))
+                case R1:
+                  for (; (T = o), !(d >= 258 + (T & 31) + ((T >> 5) & 31)); ) {
+                    let _, $
+                    for (T = v[0]; U < T; ) {
+                      if (V !== 0) p = bt
+                      else
+                        return (
+                          (c.bitb = D),
+                          (c.bitk = U),
+                          (x.avail_in = V),
+                          (x.total_in += I - x.next_in_index),
+                          (x.next_in_index = I),
+                          (c.write = j),
+                          c.inflate_flush(x, p)
+                        )
+                      ;(V--, (D |= (x.read_byte(I++) & 255) << U), (U += 8))
+                    }
+                    if (
+                      ((T = R[(A[0] + (D & we[T])) * 3 + 1]),
+                      ($ = R[(A[0] + (D & we[T])) * 3 + 2]),
+                      $ < 16)
+                    )
+                      ((D >>>= T), (U -= T), (y[d++] = $))
+                    else {
+                      for (
+                        L = $ == 18 ? 7 : $ - 14, _ = $ == 18 ? 11 : 3;
+                        U < T + L;
+                      ) {
+                        if (V !== 0) p = bt
+                        else
+                          return (
+                            (c.bitb = D),
+                            (c.bitk = U),
+                            (x.avail_in = V),
+                            (x.total_in += I - x.next_in_index),
+                            (x.next_in_index = I),
+                            (c.write = j),
+                            c.inflate_flush(x, p)
+                          )
+                        ;(V--, (D |= (x.read_byte(I++) & 255) << U), (U += 8))
+                      }
+                      if (
+                        ((D >>>= T),
+                        (U -= T),
+                        (_ += D & we[L]),
+                        (D >>>= L),
+                        (U -= L),
+                        (L = d),
+                        (T = o),
+                        L + _ > 258 + (T & 31) + ((T >> 5) & 31) ||
+                          ($ == 16 && L < 1))
+                      )
+                        return (
+                          (y = null),
+                          (f = pa),
+                          (x.msg = 'invalid bit length repeat'),
+                          (p = Ht),
+                          (c.bitb = D),
+                          (c.bitk = U),
+                          (x.avail_in = V),
+                          (x.total_in += I - x.next_in_index),
+                          (x.next_in_index = I),
+                          (c.write = j),
+                          c.inflate_flush(x, p)
+                        )
+                      $ = $ == 16 ? y[L - 1] : 0
+                      do y[L++] = $
+                      while (--_ !== 0)
+                      d = L
+                    }
+                  }
+                  if (
+                    ((A[0] = -1),
+                    (tt = []),
+                    (ot = []),
+                    (at = []),
+                    (M = []),
+                    (tt[0] = 9),
+                    (ot[0] = 6),
+                    (T = o),
+                    (T = N.inflate_trees_dynamic(
+                      257 + (T & 31),
+                      1 + ((T >> 5) & 31),
+                      y,
+                      tt,
+                      ot,
+                      at,
+                      M,
+                      R,
+                      x,
+                    )),
+                    T != bt)
+                  )
+                    return (
+                      T == Ht && ((y = null), (f = pa)),
+                      (p = T),
+                      (c.bitb = D),
+                      (c.bitk = U),
+                      (x.avail_in = V),
+                      (x.total_in += I - x.next_in_index),
+                      (x.next_in_index = I),
+                      (c.write = j),
+                      c.inflate_flush(x, p)
+                    )
+                  ;(E.init(tt[0], ot[0], R, at[0], R, M[0]), (f = Wu))
+                case Wu:
+                  if (
+                    ((c.bitb = D),
+                    (c.bitk = U),
+                    (x.avail_in = V),
+                    (x.total_in += I - x.next_in_index),
+                    (x.next_in_index = I),
+                    (c.write = j),
+                    (p = E.proc(c, x, p)) != mn)
+                  )
+                    return c.inflate_flush(x, p)
+                  if (
+                    ((p = bt),
+                    E.free(x),
+                    (I = x.next_in_index),
+                    (V = x.avail_in),
+                    (D = c.bitb),
+                    (U = c.bitk),
+                    (j = c.write),
+                    (G = j < c.read ? c.read - j - 1 : c.end - j),
+                    w === 0)
+                  ) {
+                    f = hl
+                    break
+                  }
+                  f = Fu
+                case Fu:
+                  if (
+                    ((c.write = j),
+                    (p = c.inflate_flush(x, p)),
+                    (j = c.write),
+                    (G = j < c.read ? c.read - j - 1 : c.end - j),
+                    c.read != c.write)
+                  )
+                    return (
+                      (c.bitb = D),
+                      (c.bitk = U),
+                      (x.avail_in = V),
+                      (x.total_in += I - x.next_in_index),
+                      (x.next_in_index = I),
+                      (c.write = j),
+                      c.inflate_flush(x, p)
+                    )
+                  f = O1
+                case O1:
+                  return (
+                    (p = mn),
+                    (c.bitb = D),
+                    (c.bitk = U),
+                    (x.avail_in = V),
+                    (x.total_in += I - x.next_in_index),
+                    (x.next_in_index = I),
+                    (c.write = j),
+                    c.inflate_flush(x, p)
+                  )
+                case pa:
+                  return (
+                    (p = Ht),
+                    (c.bitb = D),
+                    (c.bitk = U),
+                    (x.avail_in = V),
+                    (x.total_in += I - x.next_in_index),
+                    (x.next_in_index = I),
+                    (c.write = j),
+                    c.inflate_flush(x, p)
+                  )
+                default:
+                  return (
+                    (p = me),
+                    (c.bitb = D),
+                    (c.bitk = U),
+                    (x.avail_in = V),
+                    (x.total_in += I - x.next_in_index),
+                    (x.next_in_index = I),
+                    (c.write = j),
+                    c.inflate_flush(x, p)
+                  )
+              }
+            }
+          }),
+          (c.free = function (x) {
+            ;(c.reset(x, null), (c.win = null), (R = null))
+          }),
+          (c.set_dictionary = function (x, p, T) {
+            ;(c.win.set(x.subarray(p, p + T), 0), (c.read = c.write = T))
+          }),
+          (c.sync_point = function () {
+            return f == Sf ? 1 : 0
+          }))
+      }
+      const MA = 32,
+        jA = 8,
+        HA = 0,
+        D1 = 1,
+        C1 = 2,
+        M1 = 3,
+        j1 = 4,
+        H1 = 5,
+        Tf = 6,
+        vi = 7,
+        N1 = 12,
+        kn = 13,
+        NA = [0, 0, 255, 255]
+      function BA() {
+        const u = this
+        ;((u.mode = 0),
+          (u.method = 0),
+          (u.was = [0]),
+          (u.need = 0),
+          (u.marker = 0),
+          (u.wbits = 0))
+        function i(c) {
+          return !c || !c.istate
+            ? me
+            : ((c.total_in = c.total_out = 0),
+              (c.msg = null),
+              (c.istate.mode = vi),
+              c.istate.blocks.reset(c, null),
+              bt)
+        }
+        ;((u.inflateEnd = function (c) {
+          return (u.blocks && u.blocks.free(c), (u.blocks = null), bt)
+        }),
+          (u.inflateInit = function (c, f) {
+            return (
+              (c.msg = null),
+              (u.blocks = null),
+              f < 8 || f > 15
+                ? (u.inflateEnd(c), me)
+                : ((u.wbits = f),
+                  (c.istate.blocks = new CA(c, 1 << f)),
+                  i(c),
+                  bt)
+            )
+          }),
+          (u.inflate = function (c, f) {
+            let r, o
+            if (!c || !c.istate || !c.next_in) return me
+            const d = c.istate
+            for (f = f == EA ? An : bt, r = An; ; )
+              switch (d.mode) {
+                case HA:
+                  if (c.avail_in === 0) return r
+                  if (
+                    ((r = f),
+                    c.avail_in--,
+                    c.total_in++,
+                    ((d.method = c.read_byte(c.next_in_index++)) & 15) != jA)
+                  ) {
+                    ;((d.mode = kn),
+                      (c.msg = 'unknown compression method'),
+                      (d.marker = 5))
+                    break
+                  }
+                  if ((d.method >> 4) + 8 > d.wbits) {
+                    ;((d.mode = kn),
+                      (c.msg = 'invalid win size'),
+                      (d.marker = 5))
+                    break
+                  }
+                  d.mode = D1
+                case D1:
+                  if (c.avail_in === 0) return r
+                  if (
+                    ((r = f),
+                    c.avail_in--,
+                    c.total_in++,
+                    (o = c.read_byte(c.next_in_index++) & 255),
+                    ((d.method << 8) + o) % 31 !== 0)
+                  ) {
+                    ;((d.mode = kn),
+                      (c.msg = 'incorrect header check'),
+                      (d.marker = 5))
+                    break
+                  }
+                  if ((o & MA) === 0) {
+                    d.mode = vi
+                    break
+                  }
+                  d.mode = C1
+                case C1:
+                  if (c.avail_in === 0) return r
+                  ;((r = f),
+                    c.avail_in--,
+                    c.total_in++,
+                    (d.need =
+                      ((c.read_byte(c.next_in_index++) & 255) << 24) &
+                      4278190080),
+                    (d.mode = M1))
+                case M1:
+                  if (c.avail_in === 0) return r
+                  ;((r = f),
+                    c.avail_in--,
+                    c.total_in++,
+                    (d.need +=
+                      ((c.read_byte(c.next_in_index++) & 255) << 16) &
+                      16711680),
+                    (d.mode = j1))
+                case j1:
+                  if (c.avail_in === 0) return r
+                  ;((r = f),
+                    c.avail_in--,
+                    c.total_in++,
+                    (d.need +=
+                      ((c.read_byte(c.next_in_index++) & 255) << 8) & 65280),
+                    (d.mode = H1))
+                case H1:
+                  return c.avail_in === 0
+                    ? r
+                    : ((r = f),
+                      c.avail_in--,
+                      c.total_in++,
+                      (d.need += c.read_byte(c.next_in_index++) & 255),
+                      (d.mode = Tf),
+                      vA)
+                case Tf:
+                  return (
+                    (d.mode = kn),
+                    (c.msg = 'need dictionary'),
+                    (d.marker = 0),
+                    me
+                  )
+                case vi:
+                  if (((r = d.blocks.proc(c, r)), r == Ht)) {
+                    ;((d.mode = kn), (d.marker = 0))
+                    break
+                  }
+                  if ((r == bt && (r = f), r != mn)) return r
+                  ;((r = f), d.blocks.reset(c, d.was), (d.mode = N1))
+                case N1:
+                  return ((c.avail_in = 0), mn)
+                case kn:
+                  return Ht
+                default:
+                  return me
+              }
+          }),
+          (u.inflateSetDictionary = function (c, f, r) {
+            let o = 0,
+              d = r
+            if (!c || !c.istate || c.istate.mode != Tf) return me
+            const y = c.istate
+            return (
+              d >= 1 << y.wbits && ((d = (1 << y.wbits) - 1), (o = r - d)),
+              y.blocks.set_dictionary(f, o, d),
+              (y.mode = vi),
+              bt
+            )
+          }),
+          (u.inflateSync = function (c) {
+            let f, r, o, d, y
+            if (!c || !c.istate) return me
+            const v = c.istate
+            if (
+              (v.mode != kn && ((v.mode = kn), (v.marker = 0)),
+              (f = c.avail_in) === 0)
+            )
+              return An
+            for (r = c.next_in_index, o = v.marker; f !== 0 && o < 4; )
+              (c.read_byte(r) == NA[o]
+                ? o++
+                : c.read_byte(r) !== 0
+                  ? (o = 0)
+                  : (o = 4 - o),
+                r++,
+                f--)
+            return (
+              (c.total_in += r - c.next_in_index),
+              (c.next_in_index = r),
+              (c.avail_in = f),
+              (v.marker = o),
+              o != 4
+                ? Ht
+                : ((d = c.total_in),
+                  (y = c.total_out),
+                  i(c),
+                  (c.total_in = d),
+                  (c.total_out = y),
+                  (v.mode = vi),
+                  bt)
+            )
+          }),
+          (u.inflateSyncPoint = function (c) {
+            return !c || !c.istate || !c.istate.blocks
+              ? me
+              : c.istate.blocks.sync_point()
+          }))
+      }
+      function T2() {}
+      T2.prototype = {
+        inflateInit(u) {
+          const i = this
+          return (
+            (i.istate = new BA()),
+            u || (u = AA),
+            i.istate.inflateInit(i, u)
+          )
+        },
+        inflate(u) {
+          const i = this
+          return i.istate ? i.istate.inflate(i, u) : me
+        },
+        inflateEnd() {
+          const u = this
+          if (!u.istate) return me
+          const i = u.istate.inflateEnd(u)
+          return ((u.istate = null), i)
+        },
+        inflateSync() {
+          const u = this
+          return u.istate ? u.istate.inflateSync(u) : me
+        },
+        inflateSetDictionary(u, i) {
+          const c = this
+          return c.istate ? c.istate.inflateSetDictionary(c, u, i) : me
+        },
+        read_byte(u) {
+          return this.next_in[u]
+        },
+        read_buf(u, i) {
+          return this.next_in.subarray(u, u + i)
+        },
+      }
+      function UA(u) {
+        const i = this,
+          c = new T2(),
+          f = u && u.chunkSize ? Math.floor(u.chunkSize * 2) : 128 * 1024,
+          r = yA,
+          o = new Uint8Array(f)
+        let d = !1
+        ;(c.inflateInit(),
+          (c.next_out = o),
+          (i.append = function (y, v) {
+            const A = []
+            let E,
+              w,
+              R = 0,
+              z = 0,
+              N = 0
+            if (y.length !== 0) {
+              ;((c.next_in_index = 0), (c.next_in = y), (c.avail_in = y.length))
+              do {
+                if (
+                  ((c.next_out_index = 0),
+                  (c.avail_out = f),
+                  c.avail_in === 0 && !d && ((c.next_in_index = 0), (d = !0)),
+                  (E = c.inflate(r)),
+                  d && E === An)
+                ) {
+                  if (c.avail_in !== 0) throw new Error('inflating: bad input')
+                } else if (E !== bt && E !== mn)
+                  throw new Error('inflating: ' + c.msg)
+                if ((d || E === mn) && c.avail_in === y.length)
+                  throw new Error('inflating: bad input')
+                ;(c.next_out_index &&
+                  (c.next_out_index === f
+                    ? A.push(new Uint8Array(o))
+                    : A.push(o.subarray(0, c.next_out_index))),
+                  (N += c.next_out_index),
+                  v &&
+                    c.next_in_index > 0 &&
+                    c.next_in_index != R &&
+                    (v(c.next_in_index), (R = c.next_in_index)))
+              } while (c.avail_in > 0 || c.avail_out === 0)
+              return (
+                A.length > 1
+                  ? ((w = new Uint8Array(N)),
+                    A.forEach(function (x) {
+                      ;(w.set(x, z), (z += x.length))
+                    }))
+                  : (w = A[0] ? new Uint8Array(A[0]) : new Uint8Array()),
+                w
+              )
+            }
+          }),
+          (i.flush = function () {
+            c.inflateEnd()
+          }))
+      }
+      const Sa = 4294967295,
+        Fn = 65535,
+        QA = 8,
+        YA = 0,
+        LA = 99,
+        zA = 67324752,
+        w2 = 134695760,
+        GA = w2,
+        B1 = 33639248,
+        XA = 101010256,
+        U1 = 101075792,
+        VA = 117853008,
+        gn = 22,
+        wf = 20,
+        Rf = 56,
+        IA = 12,
+        ZA = 20,
+        Q1 = 4,
+        qA = 1,
+        kA = 39169,
+        KA = 10,
+        WA = 1,
+        FA = 21589,
+        JA = 28789,
+        PA = 25461,
+        _A = 6534,
+        Y1 = 1,
+        $A = 6,
+        L1 = 8,
+        z1 = 2048,
+        G1 = 16,
+        t8 = 61440,
+        e8 = 16384,
+        n8 = 73,
+        X1 = '/',
+        Of = 30,
+        a8 = 10,
+        l8 = 14,
+        i8 = 18,
+        qt = void 0,
+        $n = 'undefined',
+        Oi = 'function'
+      class V1 {
+        constructor(i) {
+          return class extends TransformStream {
+            constructor(c, f) {
+              const r = new i(f)
+              super({
+                transform(o, d) {
+                  d.enqueue(r.append(o))
+                },
+                flush(o) {
+                  const d = r.flush()
+                  d && o.enqueue(d)
+                },
+              })
+            }
+          }
+        }
+      }
+      const u8 = 64
+      let R2 = 2
+      try {
+        typeof navigator != $n &&
+          navigator.hardwareConcurrency &&
+          (R2 = navigator.hardwareConcurrency)
+      } catch {}
+      const c8 = {
+          chunkSize: 512 * 1024,
+          maxWorkers: R2,
+          terminateWorkerTimeout: 5e3,
+          useWebWorkers: !0,
+          useCompressionStream: !0,
+          workerScripts: qt,
+          CompressionStreamNative:
+            typeof CompressionStream != $n && CompressionStream,
+          DecompressionStreamNative:
+            typeof DecompressionStream != $n && DecompressionStream,
+        },
+        Jn = Object.assign({}, c8)
+      function O2() {
+        return Jn
+      }
+      function s8(u) {
+        return Math.max(u.chunkSize, u8)
+      }
+      function D2(u) {
+        const {
+          baseURL: i,
+          chunkSize: c,
+          maxWorkers: f,
+          terminateWorkerTimeout: r,
+          useCompressionStream: o,
+          useWebWorkers: d,
+          Deflate: y,
+          Inflate: v,
+          CompressionStream: A,
+          DecompressionStream: E,
+          workerScripts: w,
+        } = u
+        if (
+          (Kn('baseURL', i),
+          Kn('chunkSize', c),
+          Kn('maxWorkers', f),
+          Kn('terminateWorkerTimeout', r),
+          Kn('useCompressionStream', o),
+          Kn('useWebWorkers', d),
+          y && (Jn.CompressionStream = new V1(y)),
+          v && (Jn.DecompressionStream = new V1(v)),
+          Kn('CompressionStream', A),
+          Kn('DecompressionStream', E),
+          w !== qt)
+        ) {
+          const { deflate: R, inflate: z } = w
+          if (((R || z) && (Jn.workerScripts || (Jn.workerScripts = {})), R)) {
+            if (!Array.isArray(R))
+              throw new Error('workerScripts.deflate must be an array')
+            Jn.workerScripts.deflate = R
+          }
+          if (z) {
+            if (!Array.isArray(z))
+              throw new Error('workerScripts.inflate must be an array')
+            Jn.workerScripts.inflate = z
+          }
+        }
+      }
+      function Kn(u, i) {
+        i !== qt && (Jn[u] = i)
+      }
+      function f8() {
+        return 'application/octet-stream'
+      }
+      const C2 = []
+      for (let u = 0; u < 256; u++) {
+        let i = u
+        for (let c = 0; c < 8; c++)
+          i & 1 ? (i = (i >>> 1) ^ 3988292384) : (i = i >>> 1)
+        C2[u] = i
+      }
+      class ec {
+        constructor(i) {
+          this.crc = i || -1
+        }
+        append(i) {
+          let c = this.crc | 0
+          for (let f = 0, r = i.length | 0; f < r; f++)
+            c = (c >>> 8) ^ C2[(c ^ i[f]) & 255]
+          this.crc = c
+        }
+        get() {
+          return ~this.crc
+        }
+      }
+      class M2 extends TransformStream {
+        constructor() {
+          let i
+          const c = new ec()
+          ;(super({
+            transform(f, r) {
+              ;(c.append(f), r.enqueue(f))
+            },
+            flush() {
+              const f = new Uint8Array(4)
+              ;(new DataView(f.buffer).setUint32(0, c.get()), (i.value = f))
+            },
+          }),
+            (i = this))
+        }
+      }
+      function r8(u) {
+        if (typeof TextEncoder == $n) {
+          u = unescape(encodeURIComponent(u))
+          const i = new Uint8Array(u.length)
+          for (let c = 0; c < i.length; c++) i[c] = u.charCodeAt(c)
+          return i
+        } else return new TextEncoder().encode(u)
+      }
+      const fe = {
+          concat(u, i) {
+            if (u.length === 0 || i.length === 0) return u.concat(i)
+            const c = u[u.length - 1],
+              f = fe.getPartial(c)
+            return f === 32
+              ? u.concat(i)
+              : fe._shiftRight(i, f, c | 0, u.slice(0, u.length - 1))
+          },
+          bitLength(u) {
+            const i = u.length
+            if (i === 0) return 0
+            const c = u[i - 1]
+            return (i - 1) * 32 + fe.getPartial(c)
+          },
+          clamp(u, i) {
+            if (u.length * 32 < i) return u
+            u = u.slice(0, Math.ceil(i / 32))
+            const c = u.length
+            return (
+              (i = i & 31),
+              c > 0 &&
+                i &&
+                (u[c - 1] = fe.partial(
+                  i,
+                  u[c - 1] & (2147483648 >> (i - 1)),
+                  1,
+                )),
+              u
+            )
+          },
+          partial(u, i, c) {
+            return u === 32
+              ? i
+              : (c ? i | 0 : i << (32 - u)) + u * 1099511627776
+          },
+          getPartial(u) {
+            return Math.round(u / 1099511627776) || 32
+          },
+          _shiftRight(u, i, c, f) {
+            for (f === void 0 && (f = []); i >= 32; i -= 32)
+              (f.push(c), (c = 0))
+            if (i === 0) return f.concat(u)
+            for (let d = 0; d < u.length; d++)
+              (f.push(c | (u[d] >>> i)), (c = u[d] << (32 - i)))
+            const r = u.length ? u[u.length - 1] : 0,
+              o = fe.getPartial(r)
+            return (
+              f.push(fe.partial((i + o) & 31, i + o > 32 ? c : f.pop(), 1)),
+              f
+            )
+          },
+        },
+        nc = {
+          bytes: {
+            fromBits(u) {
+              const c = fe.bitLength(u) / 8,
+                f = new Uint8Array(c)
+              let r
+              for (let o = 0; o < c; o++)
+                ((o & 3) === 0 && (r = u[o / 4]), (f[o] = r >>> 24), (r <<= 8))
+              return f
+            },
+            toBits(u) {
+              const i = []
+              let c,
+                f = 0
+              for (c = 0; c < u.length; c++)
+                ((f = (f << 8) | u[c]), (c & 3) === 3 && (i.push(f), (f = 0)))
+              return (c & 3 && i.push(fe.partial(8 * (c & 3), f)), i)
+            },
+          },
+        },
+        j2 = {}
+      j2.sha1 = class {
+        constructor(u) {
+          const i = this
+          ;((i.blockSize = 512),
+            (i._init = [
+              1732584193, 4023233417, 2562383102, 271733878, 3285377520,
+            ]),
+            (i._key = [1518500249, 1859775393, 2400959708, 3395469782]),
+            u
+              ? ((i._h = u._h.slice(0)),
+                (i._buffer = u._buffer.slice(0)),
+                (i._length = u._length))
+              : i.reset())
+        }
+        reset() {
+          const u = this
+          return (
+            (u._h = u._init.slice(0)),
+            (u._buffer = []),
+            (u._length = 0),
+            u
+          )
+        }
+        update(u) {
+          const i = this
+          typeof u == 'string' && (u = nc.utf8String.toBits(u))
+          const c = (i._buffer = fe.concat(i._buffer, u)),
+            f = i._length,
+            r = (i._length = f + fe.bitLength(u))
+          if (r > 9007199254740991)
+            throw new Error('Cannot hash more than 2^53 - 1 bits')
+          const o = new Uint32Array(c)
+          let d = 0
+          for (
+            let y = i.blockSize + f - ((i.blockSize + f) & (i.blockSize - 1));
+            y <= r;
+            y += i.blockSize
+          )
+            (i._block(o.subarray(16 * d, 16 * (d + 1))), (d += 1))
+          return (c.splice(0, 16 * d), i)
+        }
+        finalize() {
+          const u = this
+          let i = u._buffer
+          const c = u._h
+          i = fe.concat(i, [fe.partial(1, 1)])
+          for (let f = i.length + 2; f & 15; f++) i.push(0)
+          for (
+            i.push(Math.floor(u._length / 4294967296)), i.push(u._length | 0);
+            i.length;
+          )
+            u._block(i.splice(0, 16))
+          return (u.reset(), c)
+        }
+        _f(u, i, c, f) {
+          if (u <= 19) return (i & c) | (~i & f)
+          if (u <= 39) return i ^ c ^ f
+          if (u <= 59) return (i & c) | (i & f) | (c & f)
+          if (u <= 79) return i ^ c ^ f
+        }
+        _S(u, i) {
+          return (i << u) | (i >>> (32 - u))
+        }
+        _block(u) {
+          const i = this,
+            c = i._h,
+            f = Array(80)
+          for (let A = 0; A < 16; A++) f[A] = u[A]
+          let r = c[0],
+            o = c[1],
+            d = c[2],
+            y = c[3],
+            v = c[4]
+          for (let A = 0; A <= 79; A++) {
+            A >= 16 &&
+              (f[A] = i._S(1, f[A - 3] ^ f[A - 8] ^ f[A - 14] ^ f[A - 16]))
+            const E =
+              (i._S(5, r) +
+                i._f(A, o, d, y) +
+                v +
+                f[A] +
+                i._key[Math.floor(A / 20)]) |
+              0
+            ;((v = y), (y = d), (d = i._S(30, o)), (o = r), (r = E))
+          }
+          ;((c[0] = (c[0] + r) | 0),
+            (c[1] = (c[1] + o) | 0),
+            (c[2] = (c[2] + d) | 0),
+            (c[3] = (c[3] + y) | 0),
+            (c[4] = (c[4] + v) | 0))
+        }
+      }
+      const H2 = {}
+      H2.aes = class {
+        constructor(u) {
+          const i = this
+          ;((i._tables = [
+            [[], [], [], [], []],
+            [[], [], [], [], []],
+          ]),
+            i._tables[0][0][0] || i._precompute())
+          const c = i._tables[0][4],
+            f = i._tables[1],
+            r = u.length
+          let o,
+            d,
+            y,
+            v = 1
+          if (r !== 4 && r !== 6 && r !== 8)
+            throw new Error('invalid aes key size')
+          for (
+            i._key = [(d = u.slice(0)), (y = [])], o = r;
+            o < 4 * r + 28;
+            o++
+          ) {
+            let A = d[o - 1]
+            ;((o % r === 0 || (r === 8 && o % r === 4)) &&
+              ((A =
+                (c[A >>> 24] << 24) ^
+                (c[(A >> 16) & 255] << 16) ^
+                (c[(A >> 8) & 255] << 8) ^
+                c[A & 255]),
+              o % r === 0 &&
+                ((A = (A << 8) ^ (A >>> 24) ^ (v << 24)),
+                (v = (v << 1) ^ ((v >> 7) * 283)))),
+              (d[o] = d[o - r] ^ A))
+          }
+          for (let A = 0; o; A++, o--) {
+            const E = d[A & 3 ? o : o - 4]
+            o <= 4 || A < 4
+              ? (y[A] = E)
+              : (y[A] =
+                  f[0][c[E >>> 24]] ^
+                  f[1][c[(E >> 16) & 255]] ^
+                  f[2][c[(E >> 8) & 255]] ^
+                  f[3][c[E & 255]])
+          }
+        }
+        encrypt(u) {
+          return this._crypt(u, 0)
+        }
+        decrypt(u) {
+          return this._crypt(u, 1)
+        }
+        _precompute() {
+          const u = this._tables[0],
+            i = this._tables[1],
+            c = u[4],
+            f = i[4],
+            r = [],
+            o = []
+          let d, y, v, A
+          for (let E = 0; E < 256; E++)
+            o[(r[E] = (E << 1) ^ ((E >> 7) * 283)) ^ E] = E
+          for (let E = (d = 0); !c[E]; E ^= y || 1, d = o[d] || 1) {
+            let w = d ^ (d << 1) ^ (d << 2) ^ (d << 3) ^ (d << 4)
+            ;((w = (w >> 8) ^ (w & 255) ^ 99),
+              (c[E] = w),
+              (f[w] = E),
+              (A = r[(v = r[(y = r[E])])]))
+            let R = (A * 16843009) ^ (v * 65537) ^ (y * 257) ^ (E * 16843008),
+              z = (r[w] * 257) ^ (w * 16843008)
+            for (let N = 0; N < 4; N++)
+              ((u[N][E] = z = (z << 24) ^ (z >>> 8)),
+                (i[N][w] = R = (R << 24) ^ (R >>> 8)))
+          }
+          for (let E = 0; E < 5; E++)
+            ((u[E] = u[E].slice(0)), (i[E] = i[E].slice(0)))
+        }
+        _crypt(u, i) {
+          if (u.length !== 4) throw new Error('invalid aes block size')
+          const c = this._key[i],
+            f = c.length / 4 - 2,
+            r = [0, 0, 0, 0],
+            o = this._tables[i],
+            d = o[0],
+            y = o[1],
+            v = o[2],
+            A = o[3],
+            E = o[4]
+          let w = u[0] ^ c[0],
+            R = u[i ? 3 : 1] ^ c[1],
+            z = u[2] ^ c[2],
+            N = u[i ? 1 : 3] ^ c[3],
+            x = 4,
+            p,
+            T,
+            D
+          for (let U = 0; U < f; U++)
+            ((p =
+              d[w >>> 24] ^
+              y[(R >> 16) & 255] ^
+              v[(z >> 8) & 255] ^
+              A[N & 255] ^
+              c[x]),
+              (T =
+                d[R >>> 24] ^
+                y[(z >> 16) & 255] ^
+                v[(N >> 8) & 255] ^
+                A[w & 255] ^
+                c[x + 1]),
+              (D =
+                d[z >>> 24] ^
+                y[(N >> 16) & 255] ^
+                v[(w >> 8) & 255] ^
+                A[R & 255] ^
+                c[x + 2]),
+              (N =
+                d[N >>> 24] ^
+                y[(w >> 16) & 255] ^
+                v[(R >> 8) & 255] ^
+                A[z & 255] ^
+                c[x + 3]),
+              (x += 4),
+              (w = p),
+              (R = T),
+              (z = D))
+          for (let U = 0; U < 4; U++)
+            ((r[i ? 3 & -U : U] =
+              (E[w >>> 24] << 24) ^
+              (E[(R >> 16) & 255] << 16) ^
+              (E[(z >> 8) & 255] << 8) ^
+              E[N & 255] ^
+              c[x++]),
+              (p = w),
+              (w = R),
+              (R = z),
+              (z = N),
+              (N = p))
+          return r
+        }
+      }
+      const o8 = {
+          getRandomValues(u) {
+            const i = new Uint32Array(u.buffer),
+              c = (f) => {
+                let r = 987654321
+                const o = 4294967295
+                return function () {
+                  return (
+                    (r = (36969 * (r & 65535) + (r >> 16)) & o),
+                    (f = (18e3 * (f & 65535) + (f >> 16)) & o),
+                    ((((r << 16) + f) & o) / 4294967296 + 0.5) *
+                      (Math.random() > 0.5 ? 1 : -1)
+                  )
+                }
+              }
+            for (let f = 0, r; f < u.length; f += 4) {
+              const o = c((r || Math.random()) * 4294967296)
+              ;((r = o() * 987654071), (i[f / 4] = (o() * 4294967296) | 0))
+            }
+            return u
+          },
+        },
+        N2 = {}
+      N2.ctrGladman = class {
+        constructor(u, i) {
+          ;((this._prf = u), (this._initIv = i), (this._iv = i))
+        }
+        reset() {
+          this._iv = this._initIv
+        }
+        update(u) {
+          return this.calculate(this._prf, u, this._iv)
+        }
+        incWord(u) {
+          if (((u >> 24) & 255) === 255) {
+            let i = (u >> 16) & 255,
+              c = (u >> 8) & 255,
+              f = u & 255
+            ;(i === 255
+              ? ((i = 0),
+                c === 255 ? ((c = 0), f === 255 ? (f = 0) : ++f) : ++c)
+              : ++i,
+              (u = 0),
+              (u += i << 16),
+              (u += c << 8),
+              (u += f))
+          } else u += 1 << 24
+          return u
+        }
+        incCounter(u) {
+          ;(u[0] = this.incWord(u[0])) === 0 && (u[1] = this.incWord(u[1]))
+        }
+        calculate(u, i, c) {
+          let f
+          if (!(f = i.length)) return []
+          const r = fe.bitLength(i)
+          for (let o = 0; o < f; o += 4) {
+            this.incCounter(c)
+            const d = u.encrypt(c)
+            ;((i[o] ^= d[0]),
+              (i[o + 1] ^= d[1]),
+              (i[o + 2] ^= d[2]),
+              (i[o + 3] ^= d[3]))
+          }
+          return fe.clamp(i, r)
+        }
+      }
+      const Ta = {
+        importKey(u) {
+          return new Ta.hmacSha1(nc.bytes.toBits(u))
+        },
+        pbkdf2(u, i, c, f) {
+          if (((c = c || 1e4), f < 0 || c < 0))
+            throw new Error('invalid params to pbkdf2')
+          const r = ((f >> 5) + 1) << 2
+          let o, d, y, v, A
+          const E = new ArrayBuffer(r),
+            w = new DataView(E)
+          let R = 0
+          const z = fe
+          for (i = nc.bytes.toBits(i), A = 1; R < (r || 1); A++) {
+            for (o = d = u.encrypt(z.concat(i, [A])), y = 1; y < c; y++)
+              for (d = u.encrypt(d), v = 0; v < d.length; v++) o[v] ^= d[v]
+            for (y = 0; R < (r || 1) && y < o.length; y++)
+              (w.setInt32(R, o[y]), (R += 4))
+          }
+          return E.slice(0, f / 8)
+        },
+      }
+      Ta.hmacSha1 = class {
+        constructor(u) {
+          const i = this,
+            c = (i._hash = j2.sha1),
+            f = [[], []]
+          i._baseHash = [new c(), new c()]
+          const r = i._baseHash[0].blockSize / 32
+          u.length > r && (u = new c().update(u).finalize())
+          for (let o = 0; o < r; o++)
+            ((f[0][o] = u[o] ^ 909522486), (f[1][o] = u[o] ^ 1549556828))
+          ;(i._baseHash[0].update(f[0]),
+            i._baseHash[1].update(f[1]),
+            (i._resultHash = new c(i._baseHash[0])))
+        }
+        reset() {
+          const u = this
+          ;((u._resultHash = new u._hash(u._baseHash[0])), (u._updated = !1))
+        }
+        update(u) {
+          const i = this
+          ;((i._updated = !0), i._resultHash.update(u))
+        }
+        digest() {
+          const u = this,
+            i = u._resultHash.finalize(),
+            c = new u._hash(u._baseHash[1]).update(i).finalize()
+          return (u.reset(), c)
+        }
+        encrypt(u) {
+          if (this._updated)
+            throw new Error('encrypt on already updated hmac called!')
+          return (this.update(u), this.digest(u))
+        }
+      }
+      const d8 = typeof crypto != $n && typeof crypto.getRandomValues == Oi,
+        tr = 'Invalid password',
+        er = 'Invalid signature',
+        nr = 'zipjs-abort-check-password'
+      function B2(u) {
+        return d8 ? crypto.getRandomValues(u) : o8.getRandomValues(u)
+      }
+      const gl = 16,
+        h8 = 'raw',
+        U2 = { name: 'PBKDF2' },
+        g8 = { name: 'HMAC' },
+        m8 = 'SHA-1',
+        A8 = Object.assign({ hash: g8 }, U2),
+        Vf = Object.assign({ iterations: 1e3, hash: { name: m8 } }, U2),
+        v8 = ['deriveBits'],
+        xi = [8, 12, 16],
+        yi = [16, 24, 32],
+        Wn = 10,
+        y8 = [0, 0, 0, 0],
+        ic = typeof crypto != $n,
+        Di = ic && crypto.subtle,
+        Q2 = ic && typeof Di != $n,
+        We = nc.bytes,
+        E8 = H2.aes,
+        b8 = N2.ctrGladman,
+        p8 = Ta.hmacSha1
+      let I1 = ic && Q2 && typeof Di.importKey == Oi,
+        Z1 = ic && Q2 && typeof Di.deriveBits == Oi
+      class x8 extends TransformStream {
+        constructor({
+          password: i,
+          rawPassword: c,
+          signed: f,
+          encryptionStrength: r,
+          checkPasswordOnly: o,
+        }) {
+          super({
+            start() {
+              Object.assign(this, {
+                ready: new Promise((d) => (this.resolveReady = d)),
+                password: z2(i, c),
+                signed: f,
+                strength: r - 1,
+                pending: new Uint8Array(),
+              })
+            },
+            async transform(d, y) {
+              const v = this,
+                { password: A, strength: E, resolveReady: w, ready: R } = v
+              A
+                ? (await T8(v, E, A, Ue(d, 0, xi[E] + 2)),
+                  (d = Ue(d, xi[E] + 2)),
+                  o ? y.error(new Error(nr)) : w())
+                : await R
+              const z = new Uint8Array(d.length - Wn - ((d.length - Wn) % gl))
+              y.enqueue(Y2(v, d, z, 0, Wn, !0))
+            },
+            async flush(d) {
+              const { signed: y, ctr: v, hmac: A, pending: E, ready: w } = this
+              if (A && v) {
+                await w
+                const R = Ue(E, 0, E.length - Wn),
+                  z = Ue(E, E.length - Wn)
+                let N = new Uint8Array()
+                if (R.length) {
+                  const x = Ti(We, R)
+                  A.update(x)
+                  const p = v.update(x)
+                  N = Si(We, p)
+                }
+                if (y) {
+                  const x = Ue(Si(We, A.digest()), 0, Wn)
+                  for (let p = 0; p < Wn; p++)
+                    if (x[p] != z[p]) throw new Error(er)
+                }
+                d.enqueue(N)
+              }
+            },
+          })
+        }
+      }
+      class S8 extends TransformStream {
+        constructor({ password: i, rawPassword: c, encryptionStrength: f }) {
+          let r
+          ;(super({
+            start() {
+              Object.assign(this, {
+                ready: new Promise((o) => (this.resolveReady = o)),
+                password: z2(i, c),
+                strength: f - 1,
+                pending: new Uint8Array(),
+              })
+            },
+            async transform(o, d) {
+              const y = this,
+                { password: v, strength: A, resolveReady: E, ready: w } = y
+              let R = new Uint8Array()
+              v ? ((R = await w8(y, A, v)), E()) : await w
+              const z = new Uint8Array(R.length + o.length - (o.length % gl))
+              ;(z.set(R, 0), d.enqueue(Y2(y, o, z, R.length, 0)))
+            },
+            async flush(o) {
+              const { ctr: d, hmac: y, pending: v, ready: A } = this
+              if (y && d) {
+                await A
+                let E = new Uint8Array()
+                if (v.length) {
+                  const w = d.update(Ti(We, v))
+                  ;(y.update(w), (E = Si(We, w)))
+                }
+                ;((r.signature = Si(We, y.digest()).slice(0, Wn)),
+                  o.enqueue(ar(E, r.signature)))
+              }
+            },
+          }),
+            (r = this))
+        }
+      }
+      function Y2(u, i, c, f, r, o) {
+        const { ctr: d, hmac: y, pending: v } = u,
+          A = i.length - r
+        v.length && ((i = ar(v, i)), (c = D8(c, A - (A % gl))))
+        let E
+        for (E = 0; E <= A - gl; E += gl) {
+          const w = Ti(We, Ue(i, E, E + gl))
+          o && y.update(w)
+          const R = d.update(w)
+          ;(o || y.update(R), c.set(Si(We, R), E + f))
+        }
+        return ((u.pending = Ue(i, E)), c)
+      }
+      async function T8(u, i, c, f) {
+        const r = await L2(u, i, c, Ue(f, 0, xi[i])),
+          o = Ue(f, xi[i])
+        if (r[0] != o[0] || r[1] != o[1]) throw new Error(tr)
+      }
+      async function w8(u, i, c) {
+        const f = B2(new Uint8Array(xi[i])),
+          r = await L2(u, i, c, f)
+        return ar(f, r)
+      }
+      async function L2(u, i, c, f) {
+        u.password = null
+        const r = await R8(h8, c, A8, !1, v8),
+          o = await O8(Object.assign({ salt: f }, Vf), r, 8 * (yi[i] * 2 + 2)),
+          d = new Uint8Array(o),
+          y = Ti(We, Ue(d, 0, yi[i])),
+          v = Ti(We, Ue(d, yi[i], yi[i] * 2)),
+          A = Ue(d, yi[i] * 2)
+        return (
+          Object.assign(u, {
+            keys: { key: y, authentication: v, passwordVerification: A },
+            ctr: new b8(new E8(y), Array.from(y8)),
+            hmac: new p8(v),
+          }),
+          A
+        )
+      }
+      async function R8(u, i, c, f, r) {
+        if (I1)
+          try {
+            return await Di.importKey(u, i, c, f, r)
+          } catch {
+            return ((I1 = !1), Ta.importKey(i))
+          }
+        else return Ta.importKey(i)
+      }
+      async function O8(u, i, c) {
+        if (Z1)
+          try {
+            return await Di.deriveBits(u, i, c)
+          } catch {
+            return ((Z1 = !1), Ta.pbkdf2(i, u.salt, Vf.iterations, c))
+          }
+        else return Ta.pbkdf2(i, u.salt, Vf.iterations, c)
+      }
+      function z2(u, i) {
+        return i === qt ? r8(u) : i
+      }
+      function ar(u, i) {
+        let c = u
+        return (
+          u.length + i.length &&
+            ((c = new Uint8Array(u.length + i.length)),
+            c.set(u, 0),
+            c.set(i, u.length)),
+          c
+        )
+      }
+      function D8(u, i) {
+        if (i && i > u.length) {
+          const c = u
+          ;((u = new Uint8Array(i)), u.set(c, 0))
+        }
+        return u
+      }
+      function Ue(u, i, c) {
+        return u.subarray(i, c)
+      }
+      function Si(u, i) {
+        return u.fromBits(i)
+      }
+      function Ti(u, i) {
+        return u.toBits(i)
+      }
+      const pi = 12
+      class C8 extends TransformStream {
+        constructor({
+          password: i,
+          passwordVerification: c,
+          checkPasswordOnly: f,
+        }) {
+          super({
+            start() {
+              ;(Object.assign(this, { password: i, passwordVerification: c }),
+                G2(this, i))
+            },
+            transform(r, o) {
+              const d = this
+              if (d.password) {
+                const y = q1(d, r.subarray(0, pi))
+                if (((d.password = null), y.at(-1) != d.passwordVerification))
+                  throw new Error(tr)
+                r = r.subarray(pi)
+              }
+              f ? o.error(new Error(nr)) : o.enqueue(q1(d, r))
+            },
+          })
+        }
+      }
+      class M8 extends TransformStream {
+        constructor({ password: i, passwordVerification: c }) {
+          super({
+            start() {
+              ;(Object.assign(this, { password: i, passwordVerification: c }),
+                G2(this, i))
+            },
+            transform(f, r) {
+              const o = this
+              let d, y
+              if (o.password) {
+                o.password = null
+                const v = B2(new Uint8Array(pi))
+                ;((v[pi - 1] = o.passwordVerification),
+                  (d = new Uint8Array(f.length + v.length)),
+                  d.set(k1(o, v), 0),
+                  (y = pi))
+              } else ((d = new Uint8Array(f.length)), (y = 0))
+              ;(d.set(k1(o, f), y), r.enqueue(d))
+            },
+          })
+        }
+      }
+      function q1(u, i) {
+        const c = new Uint8Array(i.length)
+        for (let f = 0; f < i.length; f++) ((c[f] = X2(u) ^ i[f]), lr(u, c[f]))
+        return c
+      }
+      function k1(u, i) {
+        const c = new Uint8Array(i.length)
+        for (let f = 0; f < i.length; f++) ((c[f] = X2(u) ^ i[f]), lr(u, i[f]))
+        return c
+      }
+      function G2(u, i) {
+        const c = [305419896, 591751049, 878082192]
+        Object.assign(u, {
+          keys: c,
+          crcKey0: new ec(c[0]),
+          crcKey2: new ec(c[2]),
+        })
+        for (let f = 0; f < i.length; f++) lr(u, i.charCodeAt(f))
+      }
+      function lr(u, i) {
+        let [c, f, r] = u.keys
+        ;(u.crcKey0.append([i]),
+          (c = ~u.crcKey0.get()),
+          (f = K1(Math.imul(K1(f + V2(c)), 134775813) + 1)),
+          u.crcKey2.append([f >>> 24]),
+          (r = ~u.crcKey2.get()),
+          (u.keys = [c, f, r]))
+      }
+      function X2(u) {
+        const i = u.keys[2] | 2
+        return V2(Math.imul(i, i ^ 1) >>> 8)
+      }
+      function V2(u) {
+        return u & 255
+      }
+      function K1(u) {
+        return u & 4294967295
+      }
+      const ir = 'Invalid uncompressed size',
+        W1 = 'deflate-raw'
+      class j8 extends TransformStream {
+        constructor(
+          i,
+          { chunkSize: c, CompressionStream: f, CompressionStreamNative: r },
+        ) {
+          super({})
+          const {
+              compressed: o,
+              encrypted: d,
+              useCompressionStream: y,
+              zipCrypto: v,
+              signed: A,
+              level: E,
+            } = i,
+            w = this
+          let R,
+            z,
+            N = super.readable
+          ;((!d || v) && A && ((R = new M2()), (N = vn(N, R))),
+            o && (N = Z2(N, y, { level: E, chunkSize: c }, r, f)),
+            d &&
+              (v ? (N = vn(N, new M8(i))) : ((z = new S8(i)), (N = vn(N, z)))),
+            I2(w, N, () => {
+              let x
+              ;(d && !v && (x = z.signature),
+                (!d || v) &&
+                  A &&
+                  (x = new DataView(R.value.buffer).getUint32(0)),
+                (w.signature = x))
+            }))
+        }
+      }
+      class H8 extends TransformStream {
+        constructor(
+          i,
+          {
+            chunkSize: c,
+            DecompressionStream: f,
+            DecompressionStreamNative: r,
+          },
+        ) {
+          super({})
+          const {
+            zipCrypto: o,
+            encrypted: d,
+            signed: y,
+            signature: v,
+            compressed: A,
+            useCompressionStream: E,
+          } = i
+          let w,
+            R,
+            z = super.readable
+          ;(d &&
+            (o ? (z = vn(z, new C8(i))) : ((R = new x8(i)), (z = vn(z, R)))),
+            A && (z = Z2(z, E, { chunkSize: c }, r, f)),
+            (!d || o) && y && ((w = new M2()), (z = vn(z, w))),
+            I2(this, z, () => {
+              if ((!d || o) && y) {
+                const N = new DataView(w.value.buffer)
+                if (v != N.getUint32(0, !1)) throw new Error(er)
+              }
+            }))
+        }
+      }
+      function I2(u, i, c) {
+        ;((i = vn(i, new TransformStream({ flush: c }))),
+          Object.defineProperty(u, 'readable', {
+            get() {
+              return i
+            },
+          }))
+      }
+      function Z2(u, i, c, f, r) {
+        try {
+          const o = i && f ? f : r
+          u = vn(u, new o(W1, c))
+        } catch (o) {
+          if (i) u = vn(u, new r(W1, c))
+          else throw o
+        }
+        return u
+      }
+      function vn(u, i) {
+        return u.pipeThrough(i)
+      }
+      const N8 = 'message',
+        B8 = 'start',
+        U8 = 'pull',
+        F1 = 'data',
+        Q8 = 'ack',
+        J1 = 'close',
+        Y8 = 'deflate',
+        q2 = 'inflate'
+      class L8 extends TransformStream {
+        constructor(i, c) {
+          super({})
+          const f = this,
+            { codecType: r } = i
+          let o
+          ;(r.startsWith(Y8) ? (o = j8) : r.startsWith(q2) && (o = H8),
+            (f.outputSize = 0))
+          let d = 0
+          const y = new o(i, c),
+            v = super.readable,
+            A = new TransformStream({
+              transform(w, R) {
+                w && w.length && ((d += w.length), R.enqueue(w))
+              },
+              flush() {
+                Object.assign(f, { inputSize: d })
+              },
+            }),
+            E = new TransformStream({
+              transform(w, R) {
+                if (
+                  w &&
+                  w.length &&
+                  (R.enqueue(w),
+                  (f.outputSize += w.length),
+                  i.outputSize && f.outputSize > i.outputSize)
+                )
+                  throw new Error(ir)
+              },
+              flush() {
+                const { signature: w } = y
+                Object.assign(f, { signature: w, inputSize: d })
+              },
+            })
+          Object.defineProperty(f, 'readable', {
+            get() {
+              return v.pipeThrough(A).pipeThrough(y).pipeThrough(E)
+            },
+          })
+        }
+      }
+      class z8 extends TransformStream {
+        constructor(i) {
+          let c
+          super({
+            transform: f,
+            flush(r) {
+              c && c.length && r.enqueue(c)
+            },
+          })
+          function f(r, o) {
+            if (c) {
+              const d = new Uint8Array(c.length + r.length)
+              ;(d.set(c), d.set(r, c.length), (r = d), (c = null))
+            }
+            r.length > i
+              ? (o.enqueue(r.slice(0, i)), f(r.slice(i), o))
+              : (c = r)
+          }
+        }
+      }
+      let k2 = typeof Worker != $n
+      class Df {
+        constructor(
+          i,
+          { readable: c, writable: f },
+          {
+            options: r,
+            config: o,
+            streamOptions: d,
+            useWebWorkers: y,
+            transferStreams: v,
+            scripts: A,
+          },
+          E,
+        ) {
+          const { signal: w } = d
+          return (
+            Object.assign(i, {
+              busy: !0,
+              readable: c
+                .pipeThrough(new z8(o.chunkSize))
+                .pipeThrough(new G8(d), { signal: w }),
+              writable: f,
+              options: Object.assign({}, r),
+              scripts: A,
+              transferStreams: v,
+              terminate() {
+                return new Promise((R) => {
+                  const { worker: z, busy: N } = i
+                  z
+                    ? (N ? (i.resolveTerminated = R) : (z.terminate(), R()),
+                      (i.interface = null))
+                    : R()
+                })
+              },
+              onTaskFinished() {
+                const { resolveTerminated: R } = i
+                ;(R &&
+                  ((i.resolveTerminated = null),
+                  (i.terminated = !0),
+                  i.worker.terminate(),
+                  R()),
+                  (i.busy = !1),
+                  E(i))
+              },
+            }),
+            (y && k2 ? X8 : K2)(i, o)
+          )
+        }
+      }
+      class G8 extends TransformStream {
+        constructor({ onstart: i, onprogress: c, size: f, onend: r }) {
+          let o = 0
+          super({
+            async start() {
+              i && (await Cf(i, f))
+            },
+            async transform(d, y) {
+              ;((o += d.length), c && (await Cf(c, o, f)), y.enqueue(d))
+            },
+            async flush() {
+              r && (await Cf(r, o))
+            },
+          })
+        }
+      }
+      async function Cf(u, ...i) {
+        try {
+          await u(...i)
+        } catch {}
+      }
+      function K2(u, i) {
+        return { run: () => V8(u, i) }
+      }
+      function X8(u, i) {
+        const { baseURL: c, chunkSize: f } = i
+        if (!u.interface) {
+          let r
+          try {
+            r = q8(u.scripts[0], c, u)
+          } catch {
+            return ((k2 = !1), K2(u, i))
+          }
+          Object.assign(u, {
+            worker: r,
+            interface: { run: () => I8(u, { chunkSize: f }) },
+          })
+        }
+        return u.interface
+      }
+      async function V8(
+        { options: u, readable: i, writable: c, onTaskFinished: f },
+        r,
+      ) {
+        let o
+        try {
+          ;((o = new L8(u, r)),
+            await i
+              .pipeThrough(o)
+              .pipeTo(c, { preventClose: !0, preventAbort: !0 }))
+          const { signature: d, inputSize: y, outputSize: v } = o
+          return { signature: d, inputSize: y, outputSize: v }
+        } catch (d) {
+          throw (o && (d.outputSize = o.outputSize), d)
+        } finally {
+          f()
+        }
+      }
+      async function I8(u, i) {
+        let c, f
+        const r = new Promise((R, z) => {
+          ;((c = R), (f = z))
+        })
+        Object.assign(u, {
+          reader: null,
+          writer: null,
+          resolveResult: c,
+          rejectResult: f,
+          result: r,
+        })
+        const { readable: o, options: d, scripts: y } = u,
+          { writable: v, closed: A } = Z8(u.writable),
+          E = _u(
+            {
+              type: B8,
+              scripts: y.slice(1),
+              options: d,
+              config: i,
+              readable: o,
+              writable: v,
+            },
+            u,
+          )
+        E || Object.assign(u, { reader: o.getReader(), writer: v.getWriter() })
+        const w = await r
+        return (E || (await v.getWriter().close()), await A, w)
+      }
+      function Z8(u) {
+        let i
+        const c = new Promise((r) => (i = r))
+        return {
+          writable: new WritableStream({
+            async write(r) {
+              const o = u.getWriter()
+              ;(await o.ready, await o.write(r), o.releaseLock())
+            },
+            close() {
+              i()
+            },
+            abort(r) {
+              return u.getWriter().abort(r)
+            },
+          }),
+          closed: c,
+        }
+      }
+      let P1 = !0,
+        _1 = !0
+      function q8(u, i, c) {
+        const f = { type: 'module' }
+        let r, o
+        typeof u == Oi && (u = u())
+        try {
+          r = new URL(u, i)
+        } catch {
+          r = u
+        }
+        if (P1)
+          try {
+            o = new Worker(r)
+          } catch {
+            ;((P1 = !1), (o = new Worker(r, f)))
+          }
+        else o = new Worker(r, f)
+        return (o.addEventListener(N8, (d) => k8(d, c)), o)
+      }
+      function _u(
+        u,
+        { worker: i, writer: c, onTaskFinished: f, transferStreams: r },
+      ) {
+        try {
+          const { value: o, readable: d, writable: y } = u,
+            v = []
+          if (
+            (o &&
+              (o.byteLength < o.buffer.byteLength
+                ? (u.value = o.buffer.slice(0, o.byteLength))
+                : (u.value = o.buffer),
+              v.push(u.value)),
+            r && _1
+              ? (d && v.push(d), y && v.push(y))
+              : (u.readable = u.writable = null),
+            v.length)
+          )
+            try {
+              return (i.postMessage(u, v), !0)
+            } catch {
+              ;((_1 = !1), (u.readable = u.writable = null), i.postMessage(u))
+            }
+          else i.postMessage(u)
+        } catch (o) {
+          throw (c && c.releaseLock(), f(), o)
+        }
+      }
+      async function k8({ data: u }, i) {
+        const { type: c, value: f, messageId: r, result: o, error: d } = u,
+          {
+            reader: y,
+            writer: v,
+            resolveResult: A,
+            rejectResult: E,
+            onTaskFinished: w,
+          } = i
+        try {
+          if (d) {
+            const { message: z, stack: N, code: x, name: p, outputSize: T } = d,
+              D = new Error(z)
+            ;(Object.assign(D, { stack: N, code: x, name: p, outputSize: T }),
+              R(D))
+          } else {
+            if (c == U8) {
+              const { value: z, done: N } = await y.read()
+              _u({ type: F1, value: z, done: N, messageId: r }, i)
+            }
+            ;(c == F1 &&
+              (await v.ready,
+              await v.write(new Uint8Array(f)),
+              _u({ type: Q8, messageId: r }, i)),
+              c == J1 && R(null, o))
+          }
+        } catch (z) {
+          ;(_u({ type: J1, messageId: r }, i), R(z))
+        }
+        function R(z, N) {
+          ;(z ? E(z) : A(N), v && v.releaseLock(), w())
+        }
+      }
+      let Pn = []
+      const Mf = []
+      let $1 = 0
+      async function K8(u, i) {
+        const { options: c, config: f } = i,
+          {
+            transferStreams: r,
+            useWebWorkers: o,
+            useCompressionStream: d,
+            codecType: y,
+            compressed: v,
+            signed: A,
+            encrypted: E,
+          } = c,
+          { workerScripts: w, maxWorkers: R } = f
+        i.transferStreams = r || r === qt
+        const z = !v && !A && !E && !i.transferStreams
+        return (
+          (i.useWebWorkers = !z && (o || (o === qt && f.useWebWorkers))),
+          (i.scripts = i.useWebWorkers && w ? w[y] : []),
+          (c.useCompressionStream = d || (d === qt && f.useCompressionStream)),
+          (await N()).run()
+        )
+        async function N() {
+          const p = Pn.find((T) => !T.busy)
+          if (p) return (If(p), new Df(p, u, i, x))
+          if (Pn.length < R) {
+            const T = { indexWorker: $1 }
+            return ($1++, Pn.push(T), new Df(T, u, i, x))
+          } else
+            return new Promise((T) =>
+              Mf.push({ resolve: T, stream: u, workerOptions: i }),
+            )
+        }
+        function x(p) {
+          if (Mf.length) {
+            const [{ resolve: T, stream: D, workerOptions: U }] = Mf.splice(
+              0,
+              1,
+            )
+            T(new Df(p, D, U, x))
+          } else p.worker ? (If(p), W8(p, i)) : (Pn = Pn.filter((T) => T != p))
+        }
+      }
+      function W8(u, i) {
+        const { config: c } = i,
+          { terminateWorkerTimeout: f } = c
+        Number.isFinite(f) &&
+          f >= 0 &&
+          (u.terminated
+            ? (u.terminated = !1)
+            : (u.terminateTimeout = setTimeout(async () => {
+                Pn = Pn.filter((r) => r != u)
+                try {
+                  await u.terminate()
+                } catch {}
+              }, f)))
+      }
+      function If(u) {
+        const { terminateTimeout: i } = u
+        i && (clearTimeout(i), (u.terminateTimeout = null))
+      }
+      async function F8() {
+        await Promise.allSettled(Pn.map((u) => (If(u), u.terminate())))
+      }
+      const W2 = 'HTTP error ',
+        Ci = 'HTTP Range not supported',
+        F2 = 'Writer iterator completed too soon',
+        J2 = 'Writer not initialized',
+        J8 = 'text/plain',
+        P8 = 'Content-Length',
+        _8 = 'Content-Range',
+        $8 = 'Accept-Ranges',
+        t3 = 'Range',
+        e3 = 'Content-Type',
+        n3 = 'HEAD',
+        ur = 'GET',
+        P2 = 'bytes',
+        a3 = 64 * 1024,
+        cr = 'writable'
+      class uc {
+        constructor() {
+          this.size = 0
+        }
+        init() {
+          this.initialized = !0
+        }
+      }
+      class ta extends uc {
+        get readable() {
+          const i = this,
+            { chunkSize: c = a3 } = i,
+            f = new ReadableStream({
+              start() {
+                this.chunkOffset = 0
+              },
+              async pull(r) {
+                const { offset: o = 0, size: d, diskNumberStart: y } = f,
+                  { chunkOffset: v } = this,
+                  A = d === qt ? c : Math.min(c, d - v),
+                  E = await Jt(i, o + v, A, y)
+                ;(r.enqueue(E),
+                  v + c > d || (d === qt && !E.length && A)
+                    ? r.close()
+                    : (this.chunkOffset += c))
+              },
+            })
+          return f
+        }
+      }
+      class sr extends uc {
+        constructor() {
+          super()
+          const i = this,
+            c = new WritableStream({
+              write(f) {
+                if (!i.initialized) throw new Error(J2)
+                return i.writeUint8Array(f)
+              },
+            })
+          Object.defineProperty(i, cr, {
+            get() {
+              return c
+            },
+          })
+        }
+        writeUint8Array() {}
+      }
+      class l3 extends ta {
+        constructor(i) {
+          super()
+          let c = i.length
+          for (; i.charAt(c - 1) == '='; ) c--
+          const f = i.indexOf(',') + 1
+          Object.assign(this, {
+            dataURI: i,
+            dataStart: f,
+            size: Math.floor((c - f) * 0.75),
+          })
+        }
+        readUint8Array(i, c) {
+          const { dataStart: f, dataURI: r } = this,
+            o = new Uint8Array(c),
+            d = Math.floor(i / 3) * 4,
+            y = atob(r.substring(d + f, Math.ceil((i + c) / 3) * 4 + f)),
+            v = i - Math.floor(d / 4) * 3
+          let A = 0
+          for (let E = v; E < v + c && E < y.length; E++)
+            ((o[E - v] = y.charCodeAt(E)), A++)
+          return A < o.length ? o.subarray(0, A) : o
+        }
+      }
+      class i3 extends sr {
+        constructor(i) {
+          ;(super(),
+            Object.assign(this, {
+              data: 'data:' + (i || '') + ';base64,',
+              pending: [],
+            }))
+        }
+        writeUint8Array(i) {
+          const c = this
+          let f = 0,
+            r = c.pending
+          const o = c.pending.length
+          for (
+            c.pending = '', f = 0;
+            f < Math.floor((o + i.length) / 3) * 3 - o;
+            f++
+          )
+            r += String.fromCharCode(i[f])
+          for (; f < i.length; f++) c.pending += String.fromCharCode(i[f])
+          r.length && (r.length > 2 ? (c.data += btoa(r)) : (c.pending += r))
+        }
+        getData() {
+          return this.data + btoa(this.pending)
+        }
+      }
+      class fr extends ta {
+        constructor(i) {
+          ;(super(), Object.assign(this, { blob: i, size: i.size }))
+        }
+        async readUint8Array(i, c) {
+          const f = this,
+            r = i + c
+          let d = await (
+            i || r < f.size ? f.blob.slice(i, r) : f.blob
+          ).arrayBuffer()
+          return (d.byteLength > c && (d = d.slice(i, r)), new Uint8Array(d))
+        }
+      }
+      class _2 extends uc {
+        constructor(i) {
+          super()
+          const c = this,
+            f = new TransformStream(),
+            r = []
+          ;(i && r.push([e3, i]),
+            Object.defineProperty(c, cr, {
+              get() {
+                return f.writable
+              },
+            }),
+            (c.blob = new Response(f.readable, { headers: r }).blob()))
+        }
+        getData() {
+          return this.blob
+        }
+      }
+      class u3 extends fr {
+        constructor(i) {
+          super(new Blob([i], { type: J8 }))
+        }
+      }
+      class c3 extends _2 {
+        constructor(i) {
+          ;(super(i),
+            Object.assign(this, {
+              encoding: i,
+              utf8: !i || i.toLowerCase() == 'utf-8',
+            }))
+        }
+        async getData() {
+          const { encoding: i, utf8: c } = this,
+            f = await super.getData()
+          if (f.text && c) return f.text()
+          {
+            const r = new FileReader()
+            return new Promise((o, d) => {
+              ;(Object.assign(r, {
+                onload: ({ target: y }) => o(y.result),
+                onerror: () => d(r.error),
+              }),
+                r.readAsText(f, i))
+            })
+          }
+        }
+      }
+      class s3 extends ta {
+        constructor(i, c) {
+          ;(super(), $2(this, i, c))
+        }
+        async init() {
+          ;(await th(this, Zf, t2), super.init())
+        }
+        readUint8Array(i, c) {
+          return eh(this, i, c, Zf, t2)
+        }
+      }
+      class f3 extends ta {
+        constructor(i, c) {
+          ;(super(), $2(this, i, c))
+        }
+        async init() {
+          ;(await th(this, qf, e2), super.init())
+        }
+        readUint8Array(i, c) {
+          return eh(this, i, c, qf, e2)
+        }
+      }
+      function $2(u, i, c) {
+        const {
+          preventHeadRequest: f,
+          useRangeHeader: r,
+          forceRangeRequests: o,
+          combineSizeEocd: d,
+        } = c
+        ;((c = Object.assign({}, c)),
+          delete c.preventHeadRequest,
+          delete c.useRangeHeader,
+          delete c.forceRangeRequests,
+          delete c.combineSizeEocd,
+          delete c.useXHR,
+          Object.assign(u, {
+            url: i,
+            options: c,
+            preventHeadRequest: f,
+            useRangeHeader: r,
+            forceRangeRequests: o,
+            combineSizeEocd: d,
+          }))
+      }
+      async function th(u, i, c) {
+        const {
+          url: f,
+          preventHeadRequest: r,
+          useRangeHeader: o,
+          forceRangeRequests: d,
+          combineSizeEocd: y,
+        } = u
+        if (h3(f) && (o || d) && (typeof r > 'u' || r)) {
+          const v = await i(ur, u, nh(u, y ? -gn : void 0))
+          if (!d && v.headers.get($8) != P2) throw new Error(Ci)
+          {
+            y && (u.eocdCache = new Uint8Array(await v.arrayBuffer()))
+            let A
+            const E = v.headers.get(_8)
+            if (E) {
+              const w = E.trim().split(/\s*\/\s*/)
+              if (w.length) {
+                const R = w[1]
+                R && R != '*' && (A = Number(R))
+              }
+            }
+            A === qt ? await n2(u, i, c) : (u.size = A)
+          }
+        } else await n2(u, i, c)
+      }
+      async function eh(u, i, c, f, r) {
+        const {
+          useRangeHeader: o,
+          forceRangeRequests: d,
+          eocdCache: y,
+          size: v,
+          options: A,
+        } = u
+        if (o || d) {
+          if (y && i == v - gn && c == gn) return y
+          if (i >= v) return new Uint8Array()
+          {
+            i + c > v && (c = v - i)
+            const E = await f(ur, u, nh(u, i, c))
+            if (E.status != 206) throw new Error(Ci)
+            return new Uint8Array(await E.arrayBuffer())
+          }
+        } else {
+          const { data: E } = u
+          return (
+            E || (await r(u, A)),
+            new Uint8Array(u.data.subarray(i, i + c))
+          )
+        }
+      }
+      function nh(u, i = 0, c = 1) {
+        return Object.assign({}, rr(u), {
+          [t3]: P2 + '=' + (i < 0 ? i : i + '-' + (i + c - 1)),
+        })
+      }
+      function rr({ options: u }) {
+        const { headers: i } = u
+        if (i) return Symbol.iterator in i ? Object.fromEntries(i) : i
+      }
+      async function t2(u) {
+        await ah(u, Zf)
+      }
+      async function e2(u) {
+        await ah(u, qf)
+      }
+      async function ah(u, i) {
+        const c = await i(ur, u, rr(u))
+        ;((u.data = new Uint8Array(await c.arrayBuffer())),
+          u.size || (u.size = u.data.length))
+      }
+      async function n2(u, i, c) {
+        if (u.preventHeadRequest) await c(u, u.options)
+        else {
+          const r = (await i(n3, u, rr(u))).headers.get(P8)
+          r ? (u.size = Number(r)) : await c(u, u.options)
+        }
+      }
+      async function Zf(u, { options: i, url: c }, f) {
+        const r = await fetch(
+          c,
+          Object.assign({}, i, { method: u, headers: f }),
+        )
+        if (r.status < 400) return r
+        throw r.status == 416
+          ? new Error(Ci)
+          : new Error(W2 + (r.statusText || r.status))
+      }
+      function qf(u, { url: i }, c) {
+        return new Promise((f, r) => {
+          const o = new XMLHttpRequest()
+          if (
+            (o.addEventListener(
+              'load',
+              () => {
+                if (o.status < 400) {
+                  const d = []
+                  ;(o
+                    .getAllResponseHeaders()
+                    .trim()
+                    .split(/[\r\n]+/)
+                    .forEach((y) => {
+                      const v = y.trim().split(/\s*:\s*/)
+                      ;((v[0] = v[0]
+                        .trim()
+                        .replace(/^[a-z]|-[a-z]/g, (A) => A.toUpperCase())),
+                        d.push(v))
+                    }),
+                    f({
+                      status: o.status,
+                      arrayBuffer: () => o.response,
+                      headers: new Map(d),
+                    }))
+                } else
+                  r(
+                    o.status == 416
+                      ? new Error(Ci)
+                      : new Error(W2 + (o.statusText || o.status)),
+                  )
+              },
+              !1,
+            ),
+            o.addEventListener(
+              'error',
+              (d) => r(d.detail ? d.detail.error : new Error('Network error')),
+              !1,
+            ),
+            o.open(u, i),
+            c)
+          )
+            for (const d of Object.entries(c)) o.setRequestHeader(d[0], d[1])
+          ;((o.responseType = 'arraybuffer'), o.send())
+        })
+      }
+      class lh extends ta {
+        constructor(i, c = {}) {
+          ;(super(),
+            Object.assign(this, {
+              url: i,
+              reader: c.useXHR ? new f3(i, c) : new s3(i, c),
+            }))
+        }
+        set size(i) {}
+        get size() {
+          return this.reader.size
+        }
+        async init() {
+          ;(await this.reader.init(), super.init())
+        }
+        readUint8Array(i, c) {
+          return this.reader.readUint8Array(i, c)
+        }
+      }
+      class r3 extends lh {
+        constructor(i, c = {}) {
+          ;((c.useRangeHeader = !0), super(i, c))
+        }
+      }
+      class o3 extends ta {
+        constructor(i) {
+          ;(super(),
+            (i = new Uint8Array(i.buffer, i.byteOffset, i.byteLength)),
+            Object.assign(this, { array: i, size: i.length }))
+        }
+        readUint8Array(i, c) {
+          return this.array.slice(i, i + c)
+        }
+      }
+      class d3 extends sr {
+        init(i = 0) {
+          ;(Object.assign(this, { offset: 0, array: new Uint8Array(i) }),
+            super.init())
+        }
+        writeUint8Array(i) {
+          const c = this
+          if (c.offset + i.length > c.array.length) {
+            const f = c.array
+            ;((c.array = new Uint8Array(f.length + i.length)), c.array.set(f))
+          }
+          ;(c.array.set(i, c.offset), (c.offset += i.length))
+        }
+        getData() {
+          return this.array
+        }
+      }
+      class or extends ta {
+        constructor(i) {
+          ;(super(), (this.readers = i))
+        }
+        async init() {
+          const i = this,
+            { readers: c } = i
+          ;((i.lastDiskNumber = 0),
+            (i.lastDiskOffset = 0),
+            await Promise.all(
+              c.map(async (f, r) => {
+                ;(await f.init(),
+                  r != c.length - 1 && (i.lastDiskOffset += f.size),
+                  (i.size += f.size))
+              }),
+            ),
+            super.init())
+        }
+        async readUint8Array(i, c, f = 0) {
+          const r = this,
+            { readers: o } = this
+          let d,
+            y = f
+          y == -1 && (y = o.length - 1)
+          let v = i
+          for (; o[y] && v >= o[y].size; ) ((v -= o[y].size), y++)
+          const A = o[y]
+          if (A) {
+            const E = A.size
+            if (v + c <= E) d = await Jt(A, v, c)
+            else {
+              const w = E - v
+              d = new Uint8Array(c)
+              const R = await Jt(A, v, w)
+              d.set(R, 0)
+              const z = await r.readUint8Array(i + w, c - w, f)
+              ;(d.set(z, w),
+                R.length + z.length < c &&
+                  (d = d.subarray(0, R.length + z.length)))
+            }
+          } else d = new Uint8Array()
+          return ((r.lastDiskNumber = Math.max(y, r.lastDiskNumber)), d)
+        }
+      }
+      class ac extends uc {
+        constructor(i, c = 4294967295) {
+          super()
+          const f = this
+          Object.assign(f, {
+            diskNumber: 0,
+            diskOffset: 0,
+            size: 0,
+            maxSize: c,
+            availableSize: c,
+          })
+          let r, o, d
+          const y = new WritableStream({
+            async write(E) {
+              const { availableSize: w } = f
+              if (d)
+                E.length >= w
+                  ? (await v(E.subarray(0, w)),
+                    await A(),
+                    (f.diskOffset += r.size),
+                    f.diskNumber++,
+                    (d = null),
+                    await this.write(E.subarray(w)))
+                  : await v(E)
+              else {
+                const { value: R, done: z } = await i.next()
+                if (z && !R) throw new Error(F2)
+                ;((r = R),
+                  (r.size = 0),
+                  r.maxSize && (f.maxSize = r.maxSize),
+                  (f.availableSize = f.maxSize),
+                  await wi(r),
+                  (o = R.writable),
+                  (d = o.getWriter()),
+                  await this.write(E))
+              }
+            },
+            async close() {
+              ;(await d.ready, await A())
+            },
+          })
+          Object.defineProperty(f, cr, {
+            get() {
+              return y
+            },
+          })
+          async function v(E) {
+            const w = E.length
+            w &&
+              (await d.ready,
+              await d.write(E),
+              (r.size += w),
+              (f.size += w),
+              (f.availableSize -= w))
+          }
+          async function A() {
+            await d.close()
+          }
+        }
+      }
+      class ih {
+        constructor(i) {
+          return (
+            Array.isArray(i) && (i = new or(i)),
+            i instanceof ReadableStream && (i = { readable: i }),
+            i
+          )
+        }
+      }
+      class uh {
+        constructor(i) {
+          return (
+            i.writable === qt && typeof i.next == Oi && (i = new ac(i)),
+            i instanceof WritableStream && (i = { writable: i }),
+            i.size === qt && (i.size = 0),
+            i instanceof ac ||
+              Object.assign(i, {
+                diskNumber: 0,
+                diskOffset: 0,
+                availableSize: 1 / 0,
+                maxSize: 1 / 0,
+              }),
+            i
+          )
+        }
+      }
+      function h3(u) {
+        const { baseURL: i } = O2(),
+          { protocol: c } = new URL(u, i)
+        return c == 'http:' || c == 'https:'
+      }
+      async function wi(u, i) {
+        if (u.init && !u.initialized) await u.init(i)
+        else return Promise.resolve()
+      }
+      function Jt(u, i, c, f) {
+        return u.readUint8Array(i, c, f)
+      }
+      const g3 = or,
+        m3 = ac,
+        ch =
+          '\0☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ '.split(
+            '',
+          ),
+        A3 = ch.length == 256
+      function v3(u) {
+        if (A3) {
+          let i = ''
+          for (let c = 0; c < u.length; c++) i += ch[u[c]]
+          return i
+        } else return new TextDecoder().decode(u)
+      }
+      function $u(u, i) {
+        return i && i.trim().toLowerCase() == 'cp437'
+          ? v3(u)
+          : new TextDecoder(i).decode(u)
+      }
+      const sh = 'filename',
+        fh = 'rawFilename',
+        rh = 'comment',
+        oh = 'rawComment',
+        dh = 'uncompressedSize',
+        hh = 'compressedSize',
+        gh = 'offset',
+        kf = 'diskNumberStart',
+        Kf = 'lastModDate',
+        Wf = 'rawLastModDate',
+        mh = 'lastAccessDate',
+        y3 = 'rawLastAccessDate',
+        Ah = 'creationDate',
+        E3 = 'rawCreationDate',
+        b3 = 'internalFileAttribute',
+        p3 = 'internalFileAttributes',
+        x3 = 'externalFileAttribute',
+        S3 = 'externalFileAttributes',
+        T3 = 'msDosCompatible',
+        w3 = 'zip64',
+        R3 = 'encrypted',
+        O3 = 'version',
+        D3 = 'versionMadeBy',
+        C3 = 'zipCrypto',
+        M3 = 'directory',
+        j3 = 'executable',
+        H3 = 'compressionMethod',
+        N3 = 'signature',
+        B3 = 'extraField',
+        U3 = [
+          sh,
+          fh,
+          hh,
+          dh,
+          Kf,
+          Wf,
+          rh,
+          oh,
+          mh,
+          Ah,
+          gh,
+          kf,
+          kf,
+          b3,
+          p3,
+          x3,
+          S3,
+          T3,
+          w3,
+          R3,
+          O3,
+          D3,
+          C3,
+          M3,
+          j3,
+          H3,
+          N3,
+          B3,
+          'bitFlag',
+          'filenameUTF8',
+          'commentUTF8',
+          'rawExtraField',
+          'extraFieldZip64',
+          'extraFieldUnicodePath',
+          'extraFieldUnicodeComment',
+          'extraFieldAES',
+          'extraFieldNTFS',
+          'extraFieldExtendedTimestamp',
+        ]
+      class a2 {
+        constructor(i) {
+          U3.forEach((c) => (this[c] = i[c]))
+        }
+      }
+      const Q3 = 'filenameEncoding',
+        Y3 = 'commentEncoding',
+        L3 = 'decodeText',
+        z3 = 'extractPrependedData',
+        G3 = 'extractAppendedData',
+        X3 = 'password',
+        V3 = 'rawPassword',
+        I3 = 'passThrough',
+        Z3 = 'signal',
+        q3 = 'checkPasswordOnly',
+        k3 = 'checkOverlappingEntryOnly',
+        K3 = 'checkOverlappingEntry',
+        W3 = 'checkSignature',
+        F3 = 'useWebWorkers',
+        J3 = 'useCompressionStream',
+        P3 = 'transferStreams',
+        _3 = 'preventClose',
+        tc = 'File format is not recognized',
+        vh = 'End of central directory not found',
+        yh = 'End of Zip64 central directory locator not found',
+        Eh = 'Central directory header not found',
+        bh = 'Local file header not found',
+        ph = 'Zip64 extra field not found',
+        xh = 'File contains encrypted entry',
+        Sh = 'Encryption method not supported',
+        Ff = 'Compression method not supported',
+        Jf = 'Split zip file',
+        Th = 'Overlapping entry found',
+        l2 = 'utf-8',
+        i2 = 'cp437',
+        $3 = [
+          [dh, Sa],
+          [hh, Sa],
+          [gh, Sa],
+          [kf, Fn],
+        ],
+        t5 = {
+          [Fn]: { getValue: jt, bytes: 4 },
+          [Sa]: { getValue: Al, bytes: 8 },
+        }
+      class wh {
+        constructor(i, c = {}) {
+          Object.assign(this, {
+            reader: new ih(i),
+            options: c,
+            config: O2(),
+            readRanges: [],
+          })
+        }
+        async *getEntriesGenerator(i = {}) {
+          const c = this
+          let { reader: f } = c
+          const { config: r } = c
+          if (
+            (await wi(f),
+            (f.size === qt || !f.readUint8Array) &&
+              ((f = new fr(await new Response(f.readable).blob())),
+              await wi(f)),
+            f.size < gn)
+          )
+            throw new Error(tc)
+          f.chunkSize = s8(r)
+          const o = await s5(f, XA, f.size, gn, Fn * 16)
+          if (!o) {
+            const F = await Jt(f, 0, 4),
+              K = Ut(F)
+            throw jt(K) == w2 ? new Error(Jf) : new Error(vh)
+          }
+          const d = Ut(o)
+          let y = jt(d, 12),
+            v = jt(d, 16)
+          const A = o.offset,
+            E = Pt(d, 20),
+            w = A + gn + E
+          let R = Pt(d, 4)
+          const z = f.lastDiskNumber || 0
+          let N = Pt(d, 6),
+            x = Pt(d, 8),
+            p = 0,
+            T = 0
+          if (v == Sa || y == Sa || x == Fn || N == Fn) {
+            const F = await Jt(f, o.offset - wf, wf),
+              K = Ut(F)
+            if (jt(K, 0) == VA) {
+              v = Al(K, 8)
+              let et = await Jt(f, v, Rf, -1),
+                tt = Ut(et)
+              const ot = o.offset - wf - Rf
+              if (jt(tt, 0) != U1 && v != ot) {
+                const at = v
+                ;((v = ot),
+                  v > at && (p = v - at),
+                  (et = await Jt(f, v, Rf, -1)),
+                  (tt = Ut(et)))
+              }
+              if (jt(tt, 0) != U1) throw new Error(yh)
+              ;(R == Fn && (R = jt(tt, 16)),
+                N == Fn && (N = jt(tt, 20)),
+                x == Fn && (x = Al(tt, 32)),
+                y == Sa && (y = Al(tt, 40)),
+                (v -= y))
+            }
+          }
+          if (
+            (v >= f.size && ((p = f.size - v - y - gn), (v = f.size - y - gn)),
+            z != R)
+          )
+            throw new Error(Jf)
+          if (v < 0) throw new Error(tc)
+          let D = 0,
+            U = await Jt(f, v, y, N),
+            I = Ut(U)
+          if (y) {
+            const F = o.offset - y
+            if (jt(I, D) != B1 && v != F) {
+              const K = v
+              ;((v = F),
+                v > K && (p += v - K),
+                (U = await Jt(f, v, y, N)),
+                (I = Ut(U)))
+            }
+          }
+          const V = o.offset - v - (f.lastDiskOffset || 0)
+          if (
+            (y != V &&
+              V >= 0 &&
+              ((y = V), (U = await Jt(f, v, y, N)), (I = Ut(U))),
+            v < 0 || v >= f.size)
+          )
+            throw new Error(tc)
+          const j = ee(c, i, Q3),
+            G = ee(c, i, Y3)
+          for (let F = 0; F < x; F++) {
+            const K = new n5(f, r, c.options)
+            if (jt(I, D) != B1) throw new Error(Eh)
+            Rh(K, I, D + 6)
+            const et = !!K.bitFlag.languageEncodingFlag,
+              tt = D + 46,
+              ot = tt + K.filenameLength,
+              at = ot + K.extraFieldLength,
+              M = Pt(I, D + 4),
+              _ = M >> 8 == 0,
+              $ = M >> 8 == 3,
+              dt = U.subarray(tt, ot),
+              b = Pt(I, D + 32),
+              q = at + b,
+              P = U.subarray(at, q),
+              J = et,
+              it = et,
+              mt = jt(I, D + 38),
+              ut =
+                (_ && (ml(I, D + 38) & G1) == G1) ||
+                ($ && ((mt >> 16) & t8) == e8) ||
+                (dt.length && dt.at(-1) == X1.charCodeAt(0)),
+              Nt = $ && ((mt >> 16) & n8) != 0,
+              Dt = jt(I, D + 42) + p
+            ;(Object.assign(K, {
+              versionMadeBy: M,
+              msDosCompatible: _,
+              compressedSize: 0,
+              uncompressedSize: 0,
+              commentLength: b,
+              directory: ut,
+              offset: Dt,
+              diskNumberStart: Pt(I, D + 34),
+              internalFileAttributes: Pt(I, D + 36),
+              externalFileAttributes: mt,
+              rawFilename: dt,
+              filenameUTF8: J,
+              commentUTF8: it,
+              rawExtraField: U.subarray(ot, at),
+              executable: Nt,
+            }),
+              (K.internalFileAttribute = K.internalFileAttributes),
+              (K.externalFileAttribute = K.externalFileAttributes))
+            const Le = ee(c, i, L3) || $u,
+              Ra = J ? l2 : j || i2,
+              ea = it ? l2 : G || i2
+            let bn = Le(dt, Ra)
+            bn === qt && (bn = $u(dt, Ra))
+            let na = Le(P, ea)
+            ;(na === qt && (na = $u(P, ea)),
+              Object.assign(K, {
+                rawComment: P,
+                filename: bn,
+                comment: na,
+                directory: ut || bn.endsWith(X1),
+              }),
+              (T = Math.max(Dt, T)),
+              Oh(K, K, I, D + 6),
+              (K.zipCrypto = K.encrypted && !K.extraFieldAES))
+            const Fe = new a2(K)
+            ;((Fe.getData = (Oa, ce) => K.getData(Oa, Fe, c.readRanges, ce)),
+              (Fe.arrayBuffer = async (Oa) => {
+                const ce = new TransformStream(),
+                  [sc] = await Promise.all([
+                    new Response(ce.readable).arrayBuffer(),
+                    K.getData(ce, Fe, c.readRanges, Oa),
+                  ])
+                return sc
+              }),
+              (D = q))
+            const { onprogress: ji } = i
+            if (ji)
+              try {
+                await ji(F + 1, x, new a2(K))
+              } catch {}
+            yield Fe
+          }
+          const L = ee(c, i, z3),
+            W = ee(c, i, G3)
+          return (
+            L &&
+              (c.prependedData = T > 0 ? await Jt(f, 0, T) : new Uint8Array()),
+            (c.comment = E ? await Jt(f, A + gn, E) : new Uint8Array()),
+            W &&
+              (c.appendedData =
+                w < f.size ? await Jt(f, w, f.size - w) : new Uint8Array()),
+            !0
+          )
+        }
+        async getEntries(i = {}) {
+          const c = []
+          for await (const f of this.getEntriesGenerator(i)) c.push(f)
+          return c
+        }
+        async close() {}
+      }
+      class e5 {
+        constructor(i = {}) {
+          const { readable: c, writable: f } = new TransformStream(),
+            r = new wh(c, i).getEntriesGenerator()
+          ;((this.readable = new ReadableStream({
+            async pull(o) {
+              const { done: d, value: y } = await r.next()
+              if (d) return o.close()
+              const v = {
+                ...y,
+                readable: (function () {
+                  const { readable: A, writable: E } = new TransformStream()
+                  if (y.getData) return (y.getData(E), A)
+                })(),
+              }
+              ;(delete v.getData, o.enqueue(v))
+            },
+          })),
+            (this.writable = f))
+        }
+      }
+      class n5 {
+        constructor(i, c, f) {
+          Object.assign(this, { reader: i, config: c, options: f })
+        }
+        async getData(i, c, f, r = {}) {
+          const o = this,
+            {
+              reader: d,
+              offset: y,
+              diskNumberStart: v,
+              extraFieldAES: A,
+              extraFieldZip64: E,
+              compressionMethod: w,
+              config: R,
+              bitFlag: z,
+              signature: N,
+              rawLastModDate: x,
+              uncompressedSize: p,
+              compressedSize: T,
+            } = o,
+            { dataDescriptor: D } = z,
+            U = (c.localDirectory = {}),
+            I = await Jt(d, y, Of, v),
+            V = Ut(I)
+          let j = ee(o, r, X3),
+            G = ee(o, r, V3)
+          const L = ee(o, r, I3)
+          if (
+            ((j = j && j.length && j),
+            (G = G && G.length && G),
+            A && A.originalCompressionMethod != LA)
+          )
+            throw new Error(Ff)
+          if (w != YA && w != QA && !L) throw new Error(Ff)
+          if (jt(V, 0) != zA) throw new Error(bh)
+          Rh(U, V, 4)
+          const {
+            extraFieldLength: W,
+            filenameLength: F,
+            lastAccessDate: K,
+            creationDate: et,
+          } = U
+          ;((U.rawExtraField = W
+            ? await Jt(d, y + Of + F, W, v)
+            : new Uint8Array()),
+            Oh(o, U, V, 4, !0),
+            Object.assign(c, { lastAccessDate: K, creationDate: et }))
+          const tt = o.encrypted && U.encrypted && !L,
+            ot = tt && !A
+          if ((L || (c.zipCrypto = ot), tt)) {
+            if (!ot && A.strength === qt) throw new Error(Sh)
+            if (!j && !G) throw new Error(xh)
+          }
+          const at = y + Of + F + W,
+            M = T,
+            _ = d.readable
+          Object.assign(_, { diskNumberStart: v, offset: at, size: M })
+          const $ = ee(o, r, Z3),
+            dt = ee(o, r, q3)
+          let b = ee(o, r, K3)
+          const q = ee(o, r, k3)
+          q && (b = !0)
+          const { onstart: P, onprogress: J, onend: it } = r,
+            mt = {
+              options: {
+                codecType: q2,
+                password: j,
+                rawPassword: G,
+                zipCrypto: ot,
+                encryptionStrength: A && A.strength,
+                signed: ee(o, r, W3) && !L,
+                passwordVerification:
+                  ot && (D ? (x >>> 8) & 255 : (N >>> 24) & 255),
+                outputSize: p,
+                signature: N,
+                compressed: w != 0 && !L,
+                encrypted: o.encrypted && !L,
+                useWebWorkers: ee(o, r, F3),
+                useCompressionStream: ee(o, r, J3),
+                transferStreams: ee(o, r, P3),
+                checkPasswordOnly: dt,
+              },
+              config: R,
+              streamOptions: {
+                signal: $,
+                size: M,
+                onstart: P,
+                onprogress: J,
+                onend: it,
+              },
+            }
+          b &&
+            (await c5({
+              reader: d,
+              fileEntry: c,
+              offset: y,
+              diskNumberStart: v,
+              signature: N,
+              compressedSize: T,
+              uncompressedSize: p,
+              dataOffset: at,
+              dataDescriptor: D || U.bitFlag.dataDescriptor,
+              extraFieldZip64: E || U.extraFieldZip64,
+              readRanges: f,
+            }))
+          let ut
+          try {
+            if (!q) {
+              ;(dt && (i = new WritableStream()),
+                (i = new uh(i)),
+                await wi(i, L ? T : p),
+                ({ writable: ut } = i))
+              const { outputSize: Nt } = await K8(
+                { readable: _, writable: ut },
+                mt,
+              )
+              if (((i.size += Nt), Nt != (L ? T : p))) throw new Error(ir)
+            }
+          } catch (Nt) {
+            if (
+              (Nt.outputSize !== qt && (i.size += Nt.outputSize),
+              !dt || Nt.message != nr)
+            )
+              throw Nt
+          } finally {
+            !ee(o, r, _3) && ut && !ut.locked && (await ut.getWriter().close())
+          }
+          return dt || q ? qt : i.getData ? i.getData() : ut
+        }
+      }
+      function Rh(u, i, c) {
+        const f = (u.rawBitFlag = Pt(i, c + 2)),
+          r = (f & Y1) == Y1,
+          o = jt(i, c + 6)
+        Object.assign(u, {
+          encrypted: r,
+          version: Pt(i, c),
+          bitFlag: {
+            level: (f & $A) >> 1,
+            dataDescriptor: (f & L1) == L1,
+            languageEncodingFlag: (f & z1) == z1,
+          },
+          rawLastModDate: o,
+          lastModDate: f5(o),
+          filenameLength: Pt(i, c + 22),
+          extraFieldLength: Pt(i, c + 24),
+        })
+      }
+      function Oh(u, i, c, f, r) {
+        const { rawExtraField: o } = i,
+          d = (i.extraField = new Map()),
+          y = Ut(new Uint8Array(o))
+        let v = 0
+        try {
+          for (; v < o.length; ) {
+            const T = Pt(y, v),
+              D = Pt(y, v + 2)
+            ;(d.set(T, { type: T, data: o.slice(v + 4, v + 4 + D) }),
+              (v += 4 + D))
+          }
+        } catch {}
+        const A = Pt(c, f + 4)
+        Object.assign(i, {
+          signature: jt(c, f + a8),
+          compressedSize: jt(c, f + l8),
+          uncompressedSize: jt(c, f + i8),
+        })
+        const E = d.get(qA)
+        E && (a5(E, i), (i.extraFieldZip64 = E))
+        const w = d.get(JA)
+        w && (u2(w, sh, fh, i, u), (i.extraFieldUnicodePath = w))
+        const R = d.get(PA)
+        R && (u2(R, rh, oh, i, u), (i.extraFieldUnicodeComment = R))
+        const z = d.get(kA)
+        z ? (l5(z, i, A), (i.extraFieldAES = z)) : (i.compressionMethod = A)
+        const N = d.get(KA)
+        N && (i5(N, i), (i.extraFieldNTFS = N))
+        const x = d.get(FA)
+        x && (u5(x, i, r), (i.extraFieldExtendedTimestamp = x))
+        const p = d.get(_A)
+        p && (i.extraFieldUSDZ = p)
+      }
+      function a5(u, i) {
+        i.zip64 = !0
+        const c = Ut(u.data),
+          f = $3.filter(([r, o]) => i[r] == o)
+        for (let r = 0, o = 0; r < f.length; r++) {
+          const [d, y] = f[r]
+          if (i[d] == y) {
+            const v = t5[y]
+            ;((i[d] = u[d] = v.getValue(c, o)), (o += v.bytes))
+          } else if (u[d]) throw new Error(ph)
+        }
+      }
+      function u2(u, i, c, f, r) {
+        const o = Ut(u.data),
+          d = new ec()
+        d.append(r[c])
+        const y = Ut(new Uint8Array(4))
+        y.setUint32(0, d.get(), !0)
+        const v = jt(o, 1)
+        ;(Object.assign(u, {
+          version: ml(o, 0),
+          [i]: $u(u.data.subarray(5)),
+          valid: !r.bitFlag.languageEncodingFlag && v == jt(y, 0),
+        }),
+          u.valid && ((f[i] = u[i]), (f[i + 'UTF8'] = !0)))
+      }
+      function l5(u, i, c) {
+        const f = Ut(u.data),
+          r = ml(f, 4)
+        ;(Object.assign(u, {
+          vendorVersion: ml(f, 0),
+          vendorId: ml(f, 2),
+          strength: r,
+          originalCompressionMethod: c,
+          compressionMethod: Pt(f, 5),
+        }),
+          (i.compressionMethod = u.compressionMethod))
+      }
+      function i5(u, i) {
+        const c = Ut(u.data)
+        let f = 4,
+          r
+        try {
+          for (; f < u.data.length && !r; ) {
+            const o = Pt(c, f),
+              d = Pt(c, f + 2)
+            ;(o == WA && (r = u.data.slice(f + 4, f + 4 + d)), (f += 4 + d))
+          }
+        } catch {}
+        try {
+          if (r && r.length == 24) {
+            const o = Ut(r),
+              d = o.getBigUint64(0, !0),
+              y = o.getBigUint64(8, !0),
+              v = o.getBigUint64(16, !0)
+            Object.assign(u, {
+              rawLastModDate: d,
+              rawLastAccessDate: y,
+              rawCreationDate: v,
+            })
+            const A = jf(d),
+              E = jf(y),
+              w = jf(v),
+              R = { lastModDate: A, lastAccessDate: E, creationDate: w }
+            ;(Object.assign(u, R), Object.assign(i, R))
+          }
+        } catch {}
+      }
+      function u5(u, i, c) {
+        const f = Ut(u.data),
+          r = ml(f, 0),
+          o = [],
+          d = []
+        c
+          ? ((r & 1) == 1 && (o.push(Kf), d.push(Wf)),
+            (r & 2) == 2 && (o.push(mh), d.push(y3)),
+            (r & 4) == 4 && (o.push(Ah), d.push(E3)))
+          : u.data.length >= 5 && (o.push(Kf), d.push(Wf))
+        let y = 1
+        o.forEach((v, A) => {
+          if (u.data.length >= y + 4) {
+            const E = jt(f, y)
+            i[v] = u[v] = new Date(E * 1e3)
+            const w = d[A]
+            u[w] = E
+          }
+          y += 4
+        })
+      }
+      async function c5({
+        reader: u,
+        fileEntry: i,
+        offset: c,
+        diskNumberStart: f,
+        signature: r,
+        compressedSize: o,
+        uncompressedSize: d,
+        dataOffset: y,
+        dataDescriptor: v,
+        extraFieldZip64: A,
+        readRanges: E,
+      }) {
+        let w = 0
+        if (f)
+          for (let N = 0; N < f; N++) {
+            const x = u.readers[N]
+            w += x.size
+          }
+        let R = 0
+        if ((v && (A ? (R = ZA) : (R = IA)), R)) {
+          const N = await Jt(u, y + o, R + Q1, f)
+          if (jt(Ut(N), 0) == GA) {
+            const p = jt(Ut(N), 4)
+            let T, D
+            ;(A
+              ? ((T = Al(Ut(N), 8)), (D = Al(Ut(N), 16)))
+              : ((T = jt(Ut(N), 8)), (D = jt(Ut(N), 12))),
+              ((i.encrypted && !i.zipCrypto) || p == r) &&
+                T == o &&
+                D == d &&
+                (R += Q1))
+          }
+        }
+        const z = { start: w + c, end: w + y + o + R, fileEntry: i }
+        for (const N of E)
+          if (N.fileEntry != i && z.start >= N.start && z.start < N.end) {
+            const x = new Error(Th)
+            throw ((x.overlappingEntry = N.fileEntry), x)
+          }
+        E.push(z)
+      }
+      async function s5(u, i, c, f, r) {
+        const o = new Uint8Array(4),
+          d = Ut(o)
+        r5(d, 0, i)
+        const y = f + r
+        return (await v(f)) || (await v(Math.min(y, c)))
+        async function v(A) {
+          const E = c - A,
+            w = await Jt(u, E, A)
+          for (let R = w.length - f; R >= 0; R--)
+            if (
+              w[R] == o[0] &&
+              w[R + 1] == o[1] &&
+              w[R + 2] == o[2] &&
+              w[R + 3] == o[3]
+            )
+              return { offset: E + R, buffer: w.slice(R, R + f).buffer }
+        }
+      }
+      function ee(u, i, c) {
+        return i[c] === qt ? u.options[c] : i[c]
+      }
+      function f5(u) {
+        const i = (u & 4294901760) >> 16,
+          c = u & 65535
+        try {
+          return new Date(
+            1980 + ((i & 65024) >> 9),
+            ((i & 480) >> 5) - 1,
+            i & 31,
+            (c & 63488) >> 11,
+            (c & 2016) >> 5,
+            (c & 31) * 2,
+            0,
+          )
+        } catch {}
+      }
+      function jf(u) {
+        return new Date(Number(u / BigInt(1e4) - BigInt(116444736e5)))
+      }
+      function ml(u, i) {
+        return u.getUint8(i)
+      }
+      function Pt(u, i) {
+        return u.getUint16(i, !0)
+      }
+      function jt(u, i) {
+        return u.getUint32(i, !0)
+      }
+      function Al(u, i) {
+        return Number(u.getBigUint64(i, !0))
+      }
+      function r5(u, i, c) {
+        u.setUint32(i, c, !0)
+      }
+      function Ut(u) {
+        return new DataView(u.buffer)
+      }
+      D2({ Inflate: UA })
+      const o5 = Object.freeze(
+        Object.defineProperty(
+          {
+            __proto__: null,
+            BlobReader: fr,
+            BlobWriter: _2,
+            Data64URIReader: l3,
+            Data64URIWriter: i3,
+            ERR_BAD_FORMAT: tc,
+            ERR_CENTRAL_DIRECTORY_NOT_FOUND: Eh,
+            ERR_ENCRYPTED: xh,
+            ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND: yh,
+            ERR_EOCDR_NOT_FOUND: vh,
+            ERR_EXTRAFIELD_ZIP64_NOT_FOUND: ph,
+            ERR_HTTP_RANGE: Ci,
+            ERR_INVALID_PASSWORD: tr,
+            ERR_INVALID_SIGNATURE: er,
+            ERR_INVALID_UNCOMPRESSED_SIZE: ir,
+            ERR_ITERATOR_COMPLETED_TOO_SOON: F2,
+            ERR_LOCAL_FILE_HEADER_NOT_FOUND: bh,
+            ERR_OVERLAPPING_ENTRY: Th,
+            ERR_SPLIT_ZIP_FILE: Jf,
+            ERR_UNSUPPORTED_COMPRESSION: Ff,
+            ERR_UNSUPPORTED_ENCRYPTION: Sh,
+            ERR_WRITER_NOT_INITIALIZED: J2,
+            GenericReader: ih,
+            GenericWriter: uh,
+            HttpRangeReader: r3,
+            HttpReader: lh,
+            Reader: ta,
+            SplitDataReader: or,
+            SplitDataWriter: ac,
+            SplitZipReader: g3,
+            SplitZipWriter: m3,
+            TextReader: u3,
+            TextWriter: c3,
+            Uint8ArrayReader: o3,
+            Uint8ArrayWriter: d3,
+            Writer: sr,
+            ZipReader: wh,
+            ZipReaderStream: e5,
+            configure: D2,
+            getMimeType: f8,
+            initStream: wi,
+            readUint8Array: Jt,
+            terminateWorkers: F8,
+          },
+          Symbol.toStringTag,
+          { value: 'Module' },
+        ),
+      )
+      var Hf = { exports: {} },
+        ht = {}
+      /**
+       * @license React
+       * react.production.js
+       *
+       * Copyright (c) Meta Platforms, Inc. and affiliates.
+       *
+       * This source code is licensed under the MIT license found in the
+       * LICENSE file in the root directory of this source tree.
+       */ var c2
+      function d5() {
+        if (c2) return ht
+        c2 = 1
+        var u = Symbol.for('react.transitional.element'),
+          i = Symbol.for('react.portal'),
+          c = Symbol.for('react.fragment'),
+          f = Symbol.for('react.strict_mode'),
+          r = Symbol.for('react.profiler'),
+          o = Symbol.for('react.consumer'),
+          d = Symbol.for('react.context'),
+          y = Symbol.for('react.forward_ref'),
+          v = Symbol.for('react.suspense'),
+          A = Symbol.for('react.memo'),
+          E = Symbol.for('react.lazy'),
+          w = Symbol.iterator
+        function R(b) {
+          return b === null || typeof b != 'object'
+            ? null
+            : ((b = (w && b[w]) || b['@@iterator']),
+              typeof b == 'function' ? b : null)
+        }
+        var z = {
+            isMounted: function () {
+              return !1
+            },
+            enqueueForceUpdate: function () {},
+            enqueueReplaceState: function () {},
+            enqueueSetState: function () {},
+          },
+          N = Object.assign,
+          x = {}
+        function p(b, q, P) {
+          ;((this.props = b),
+            (this.context = q),
+            (this.refs = x),
+            (this.updater = P || z))
+        }
+        ;((p.prototype.isReactComponent = {}),
+          (p.prototype.setState = function (b, q) {
+            if (typeof b != 'object' && typeof b != 'function' && b != null)
+              throw Error(
+                'takes an object of state variables to update or a function which returns an object of state variables.',
+              )
+            this.updater.enqueueSetState(this, b, q, 'setState')
+          }),
+          (p.prototype.forceUpdate = function (b) {
+            this.updater.enqueueForceUpdate(this, b, 'forceUpdate')
+          }))
+        function T() {}
+        T.prototype = p.prototype
+        function D(b, q, P) {
+          ;((this.props = b),
+            (this.context = q),
+            (this.refs = x),
+            (this.updater = P || z))
+        }
+        var U = (D.prototype = new T())
+        ;((U.constructor = D), N(U, p.prototype), (U.isPureReactComponent = !0))
+        var I = Array.isArray,
+          V = { H: null, A: null, T: null, S: null, V: null },
+          j = Object.prototype.hasOwnProperty
+        function G(b, q, P, J, it, mt) {
+          return (
+            (P = mt.ref),
+            {
+              $$typeof: u,
+              type: b,
+              key: q,
+              ref: P !== void 0 ? P : null,
+              props: mt,
+            }
+          )
+        }
+        function L(b, q) {
+          return G(b.type, q, void 0, void 0, void 0, b.props)
+        }
+        function W(b) {
+          return typeof b == 'object' && b !== null && b.$$typeof === u
+        }
+        function F(b) {
+          var q = { '=': '=0', ':': '=2' }
+          return (
+            '$' +
+            b.replace(/[=:]/g, function (P) {
+              return q[P]
+            })
+          )
+        }
+        var K = /\/+/g
+        function et(b, q) {
+          return typeof b == 'object' && b !== null && b.key != null
+            ? F('' + b.key)
+            : q.toString(36)
+        }
+        function tt() {}
+        function ot(b) {
+          switch (b.status) {
+            case 'fulfilled':
+              return b.value
+            case 'rejected':
+              throw b.reason
+            default:
+              switch (
+                (typeof b.status == 'string'
+                  ? b.then(tt, tt)
+                  : ((b.status = 'pending'),
+                    b.then(
+                      function (q) {
+                        b.status === 'pending' &&
+                          ((b.status = 'fulfilled'), (b.value = q))
+                      },
+                      function (q) {
+                        b.status === 'pending' &&
+                          ((b.status = 'rejected'), (b.reason = q))
+                      },
+                    )),
+                b.status)
+              ) {
+                case 'fulfilled':
+                  return b.value
+                case 'rejected':
+                  throw b.reason
+              }
+          }
+          throw b
+        }
+        function at(b, q, P, J, it) {
+          var mt = typeof b
+          ;(mt === 'undefined' || mt === 'boolean') && (b = null)
+          var ut = !1
+          if (b === null) ut = !0
+          else
+            switch (mt) {
+              case 'bigint':
+              case 'string':
+              case 'number':
+                ut = !0
+                break
+              case 'object':
+                switch (b.$$typeof) {
+                  case u:
+                  case i:
+                    ut = !0
+                    break
+                  case E:
+                    return ((ut = b._init), at(ut(b._payload), q, P, J, it))
+                }
+            }
+          if (ut)
+            return (
+              (it = it(b)),
+              (ut = J === '' ? '.' + et(b, 0) : J),
+              I(it)
+                ? ((P = ''),
+                  ut != null && (P = ut.replace(K, '$&/') + '/'),
+                  at(it, q, P, '', function (Le) {
+                    return Le
+                  }))
+                : it != null &&
+                  (W(it) &&
+                    (it = L(
+                      it,
+                      P +
+                        (it.key == null || (b && b.key === it.key)
+                          ? ''
+                          : ('' + it.key).replace(K, '$&/') + '/') +
+                        ut,
+                    )),
+                  q.push(it)),
+              1
+            )
+          ut = 0
+          var Nt = J === '' ? '.' : J + ':'
+          if (I(b))
+            for (var Dt = 0; Dt < b.length; Dt++)
+              ((J = b[Dt]), (mt = Nt + et(J, Dt)), (ut += at(J, q, P, mt, it)))
+          else if (((Dt = R(b)), typeof Dt == 'function'))
+            for (b = Dt.call(b), Dt = 0; !(J = b.next()).done; )
+              ((J = J.value),
+                (mt = Nt + et(J, Dt++)),
+                (ut += at(J, q, P, mt, it)))
+          else if (mt === 'object') {
+            if (typeof b.then == 'function') return at(ot(b), q, P, J, it)
+            throw (
+              (q = String(b)),
+              Error(
+                'Objects are not valid as a React child (found: ' +
+                  (q === '[object Object]'
+                    ? 'object with keys {' + Object.keys(b).join(', ') + '}'
+                    : q) +
+                  '). If you meant to render a collection of children, use an array instead.',
+              )
+            )
+          }
+          return ut
+        }
+        function M(b, q, P) {
+          if (b == null) return b
+          var J = [],
+            it = 0
+          return (
+            at(b, J, '', '', function (mt) {
+              return q.call(P, mt, it++)
+            }),
+            J
+          )
+        }
+        function _(b) {
+          if (b._status === -1) {
+            var q = b._result
+            ;((q = q()),
+              q.then(
+                function (P) {
+                  ;(b._status === 0 || b._status === -1) &&
+                    ((b._status = 1), (b._result = P))
+                },
+                function (P) {
+                  ;(b._status === 0 || b._status === -1) &&
+                    ((b._status = 2), (b._result = P))
+                },
+              ),
+              b._status === -1 && ((b._status = 0), (b._result = q)))
+          }
+          if (b._status === 1) return b._result.default
+          throw b._result
+        }
+        var $ =
+          typeof reportError == 'function'
+            ? reportError
+            : function (b) {
+                if (
+                  typeof window == 'object' &&
+                  typeof window.ErrorEvent == 'function'
+                ) {
+                  var q = new window.ErrorEvent('error', {
+                    bubbles: !0,
+                    cancelable: !0,
+                    message:
+                      typeof b == 'object' &&
+                      b !== null &&
+                      typeof b.message == 'string'
+                        ? String(b.message)
+                        : String(b),
+                    error: b,
+                  })
+                  if (!window.dispatchEvent(q)) return
+                } else if (
+                  typeof process == 'object' &&
+                  typeof process.emit == 'function'
+                ) {
+                  process.emit('uncaughtException', b)
+                  return
+                }
+                console.error(b)
+              }
+        function dt() {}
+        return (
+          (ht.Children = {
+            map: M,
+            forEach: function (b, q, P) {
+              M(
+                b,
+                function () {
+                  q.apply(this, arguments)
+                },
+                P,
+              )
+            },
+            count: function (b) {
+              var q = 0
+              return (
+                M(b, function () {
+                  q++
+                }),
+                q
+              )
+            },
+            toArray: function (b) {
+              return (
+                M(b, function (q) {
+                  return q
+                }) || []
+              )
+            },
+            only: function (b) {
+              if (!W(b))
+                throw Error(
+                  'React.Children.only expected to receive a single React element child.',
+                )
+              return b
+            },
+          }),
+          (ht.Component = p),
+          (ht.Fragment = c),
+          (ht.Profiler = r),
+          (ht.PureComponent = D),
+          (ht.StrictMode = f),
+          (ht.Suspense = v),
+          (ht.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =
+            V),
+          (ht.__COMPILER_RUNTIME = {
+            __proto__: null,
+            c: function (b) {
+              return V.H.useMemoCache(b)
+            },
+          }),
+          (ht.cache = function (b) {
+            return function () {
+              return b.apply(null, arguments)
+            }
+          }),
+          (ht.cloneElement = function (b, q, P) {
+            if (b == null)
+              throw Error(
+                'The argument must be a React element, but you passed ' +
+                  b +
+                  '.',
+              )
+            var J = N({}, b.props),
+              it = b.key,
+              mt = void 0
+            if (q != null)
+              for (ut in (q.ref !== void 0 && (mt = void 0),
+              q.key !== void 0 && (it = '' + q.key),
+              q))
+                !j.call(q, ut) ||
+                  ut === 'key' ||
+                  ut === '__self' ||
+                  ut === '__source' ||
+                  (ut === 'ref' && q.ref === void 0) ||
+                  (J[ut] = q[ut])
+            var ut = arguments.length - 2
+            if (ut === 1) J.children = P
+            else if (1 < ut) {
+              for (var Nt = Array(ut), Dt = 0; Dt < ut; Dt++)
+                Nt[Dt] = arguments[Dt + 2]
+              J.children = Nt
+            }
+            return G(b.type, it, void 0, void 0, mt, J)
+          }),
+          (ht.createContext = function (b) {
+            return (
+              (b = {
+                $$typeof: d,
+                _currentValue: b,
+                _currentValue2: b,
+                _threadCount: 0,
+                Provider: null,
+                Consumer: null,
+              }),
+              (b.Provider = b),
+              (b.Consumer = { $$typeof: o, _context: b }),
+              b
+            )
+          }),
+          (ht.createElement = function (b, q, P) {
+            var J,
+              it = {},
+              mt = null
+            if (q != null)
+              for (J in (q.key !== void 0 && (mt = '' + q.key), q))
+                j.call(q, J) &&
+                  J !== 'key' &&
+                  J !== '__self' &&
+                  J !== '__source' &&
+                  (it[J] = q[J])
+            var ut = arguments.length - 2
+            if (ut === 1) it.children = P
+            else if (1 < ut) {
+              for (var Nt = Array(ut), Dt = 0; Dt < ut; Dt++)
+                Nt[Dt] = arguments[Dt + 2]
+              it.children = Nt
+            }
+            if (b && b.defaultProps)
+              for (J in ((ut = b.defaultProps), ut))
+                it[J] === void 0 && (it[J] = ut[J])
+            return G(b, mt, void 0, void 0, null, it)
+          }),
+          (ht.createRef = function () {
+            return { current: null }
+          }),
+          (ht.forwardRef = function (b) {
+            return { $$typeof: y, render: b }
+          }),
+          (ht.isValidElement = W),
+          (ht.lazy = function (b) {
+            return {
+              $$typeof: E,
+              _payload: { _status: -1, _result: b },
+              _init: _,
+            }
+          }),
+          (ht.memo = function (b, q) {
+            return { $$typeof: A, type: b, compare: q === void 0 ? null : q }
+          }),
+          (ht.startTransition = function (b) {
+            var q = V.T,
+              P = {}
+            V.T = P
+            try {
+              var J = b(),
+                it = V.S
+              ;(it !== null && it(P, J),
+                typeof J == 'object' &&
+                  J !== null &&
+                  typeof J.then == 'function' &&
+                  J.then(dt, $))
+            } catch (mt) {
+              $(mt)
+            } finally {
+              V.T = q
+            }
+          }),
+          (ht.unstable_useCacheRefresh = function () {
+            return V.H.useCacheRefresh()
+          }),
+          (ht.use = function (b) {
+            return V.H.use(b)
+          }),
+          (ht.useActionState = function (b, q, P) {
+            return V.H.useActionState(b, q, P)
+          }),
+          (ht.useCallback = function (b, q) {
+            return V.H.useCallback(b, q)
+          }),
+          (ht.useContext = function (b) {
+            return V.H.useContext(b)
+          }),
+          (ht.useDebugValue = function () {}),
+          (ht.useDeferredValue = function (b, q) {
+            return V.H.useDeferredValue(b, q)
+          }),
+          (ht.useEffect = function (b, q, P) {
+            var J = V.H
+            if (typeof P == 'function')
+              throw Error(
+                'useEffect CRUD overload is not enabled in this build of React.',
+              )
+            return J.useEffect(b, q)
+          }),
+          (ht.useId = function () {
+            return V.H.useId()
+          }),
+          (ht.useImperativeHandle = function (b, q, P) {
+            return V.H.useImperativeHandle(b, q, P)
+          }),
+          (ht.useInsertionEffect = function (b, q) {
+            return V.H.useInsertionEffect(b, q)
+          }),
+          (ht.useLayoutEffect = function (b, q) {
+            return V.H.useLayoutEffect(b, q)
+          }),
+          (ht.useMemo = function (b, q) {
+            return V.H.useMemo(b, q)
+          }),
+          (ht.useOptimistic = function (b, q) {
+            return V.H.useOptimistic(b, q)
+          }),
+          (ht.useReducer = function (b, q, P) {
+            return V.H.useReducer(b, q, P)
+          }),
+          (ht.useRef = function (b) {
+            return V.H.useRef(b)
+          }),
+          (ht.useState = function (b) {
+            return V.H.useState(b)
+          }),
+          (ht.useSyncExternalStore = function (b, q, P) {
+            return V.H.useSyncExternalStore(b, q, P)
+          }),
+          (ht.useTransition = function () {
+            return V.H.useTransition()
+          }),
+          (ht.version = '19.1.1'),
+          ht
+        )
+      }
+      var s2
+      function dr() {
+        return (s2 || ((s2 = 1), (Hf.exports = d5())), Hf.exports)
+      }
+      var ct = dr()
+      const ie = hA(ct)
+      var Nf = { exports: {} },
+        Ei = {},
+        Bf = { exports: {} },
+        Uf = {}
+      /**
+       * @license React
+       * scheduler.production.js
+       *
+       * Copyright (c) Meta Platforms, Inc. and affiliates.
+       *
+       * This source code is licensed under the MIT license found in the
+       * LICENSE file in the root directory of this source tree.
+       */ var f2
+      function h5() {
+        return (
+          f2 ||
+            ((f2 = 1),
+            (function (u) {
+              function i(M, _) {
+                var $ = M.length
+                M.push(_)
+                t: for (; 0 < $; ) {
+                  var dt = ($ - 1) >>> 1,
+                    b = M[dt]
+                  if (0 < r(b, _)) ((M[dt] = _), (M[$] = b), ($ = dt))
+                  else break t
+                }
+              }
+              function c(M) {
+                return M.length === 0 ? null : M[0]
+              }
+              function f(M) {
+                if (M.length === 0) return null
+                var _ = M[0],
+                  $ = M.pop()
+                if ($ !== _) {
+                  M[0] = $
+                  t: for (var dt = 0, b = M.length, q = b >>> 1; dt < q; ) {
+                    var P = 2 * (dt + 1) - 1,
+                      J = M[P],
+                      it = P + 1,
+                      mt = M[it]
+                    if (0 > r(J, $))
+                      it < b && 0 > r(mt, J)
+                        ? ((M[dt] = mt), (M[it] = $), (dt = it))
+                        : ((M[dt] = J), (M[P] = $), (dt = P))
+                    else if (it < b && 0 > r(mt, $))
+                      ((M[dt] = mt), (M[it] = $), (dt = it))
+                    else break t
+                  }
+                }
+                return _
+              }
+              function r(M, _) {
+                var $ = M.sortIndex - _.sortIndex
+                return $ !== 0 ? $ : M.id - _.id
+              }
+              if (
+                ((u.unstable_now = void 0),
+                typeof performance == 'object' &&
+                  typeof performance.now == 'function')
+              ) {
+                var o = performance
+                u.unstable_now = function () {
+                  return o.now()
+                }
+              } else {
+                var d = Date,
+                  y = d.now()
+                u.unstable_now = function () {
+                  return d.now() - y
+                }
+              }
+              var v = [],
+                A = [],
+                E = 1,
+                w = null,
+                R = 3,
+                z = !1,
+                N = !1,
+                x = !1,
+                p = !1,
+                T = typeof setTimeout == 'function' ? setTimeout : null,
+                D = typeof clearTimeout == 'function' ? clearTimeout : null,
+                U = typeof setImmediate < 'u' ? setImmediate : null
+              function I(M) {
+                for (var _ = c(A); _ !== null; ) {
+                  if (_.callback === null) f(A)
+                  else if (_.startTime <= M)
+                    (f(A), (_.sortIndex = _.expirationTime), i(v, _))
+                  else break
+                  _ = c(A)
+                }
+              }
+              function V(M) {
+                if (((x = !1), I(M), !N))
+                  if (c(v) !== null) ((N = !0), j || ((j = !0), et()))
+                  else {
+                    var _ = c(A)
+                    _ !== null && at(V, _.startTime - M)
+                  }
+              }
+              var j = !1,
+                G = -1,
+                L = 5,
+                W = -1
+              function F() {
+                return p ? !0 : !(u.unstable_now() - W < L)
+              }
+              function K() {
+                if (((p = !1), j)) {
+                  var M = u.unstable_now()
+                  W = M
+                  var _ = !0
+                  try {
+                    t: {
+                      ;((N = !1), x && ((x = !1), D(G), (G = -1)), (z = !0))
+                      var $ = R
+                      try {
+                        e: {
+                          for (
+                            I(M), w = c(v);
+                            w !== null && !(w.expirationTime > M && F());
+                          ) {
+                            var dt = w.callback
+                            if (typeof dt == 'function') {
+                              ;((w.callback = null), (R = w.priorityLevel))
+                              var b = dt(w.expirationTime <= M)
+                              if (
+                                ((M = u.unstable_now()), typeof b == 'function')
+                              ) {
+                                ;((w.callback = b), I(M), (_ = !0))
+                                break e
+                              }
+                              ;(w === c(v) && f(v), I(M))
+                            } else f(v)
+                            w = c(v)
+                          }
+                          if (w !== null) _ = !0
+                          else {
+                            var q = c(A)
+                            ;(q !== null && at(V, q.startTime - M), (_ = !1))
+                          }
+                        }
+                        break t
+                      } finally {
+                        ;((w = null), (R = $), (z = !1))
+                      }
+                      _ = void 0
+                    }
+                  } finally {
+                    _ ? et() : (j = !1)
+                  }
+                }
+              }
+              var et
+              if (typeof U == 'function')
+                et = function () {
+                  U(K)
+                }
+              else if (typeof MessageChannel < 'u') {
+                var tt = new MessageChannel(),
+                  ot = tt.port2
+                ;((tt.port1.onmessage = K),
+                  (et = function () {
+                    ot.postMessage(null)
+                  }))
+              } else
+                et = function () {
+                  T(K, 0)
+                }
+              function at(M, _) {
+                G = T(function () {
+                  M(u.unstable_now())
+                }, _)
+              }
+              ;((u.unstable_IdlePriority = 5),
+                (u.unstable_ImmediatePriority = 1),
+                (u.unstable_LowPriority = 4),
+                (u.unstable_NormalPriority = 3),
+                (u.unstable_Profiling = null),
+                (u.unstable_UserBlockingPriority = 2),
+                (u.unstable_cancelCallback = function (M) {
+                  M.callback = null
+                }),
+                (u.unstable_forceFrameRate = function (M) {
+                  0 > M || 125 < M
+                    ? console.error(
+                        'forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported',
+                      )
+                    : (L = 0 < M ? Math.floor(1e3 / M) : 5)
+                }),
+                (u.unstable_getCurrentPriorityLevel = function () {
+                  return R
+                }),
+                (u.unstable_next = function (M) {
+                  switch (R) {
+                    case 1:
+                    case 2:
+                    case 3:
+                      var _ = 3
+                      break
+                    default:
+                      _ = R
+                  }
+                  var $ = R
+                  R = _
+                  try {
+                    return M()
+                  } finally {
+                    R = $
+                  }
+                }),
+                (u.unstable_requestPaint = function () {
+                  p = !0
+                }),
+                (u.unstable_runWithPriority = function (M, _) {
+                  switch (M) {
+                    case 1:
+                    case 2:
+                    case 3:
+                    case 4:
+                    case 5:
+                      break
+                    default:
+                      M = 3
+                  }
+                  var $ = R
+                  R = M
+                  try {
+                    return _()
+                  } finally {
+                    R = $
+                  }
+                }),
+                (u.unstable_scheduleCallback = function (M, _, $) {
+                  var dt = u.unstable_now()
+                  switch (
+                    (typeof $ == 'object' && $ !== null
+                      ? (($ = $.delay),
+                        ($ = typeof $ == 'number' && 0 < $ ? dt + $ : dt))
+                      : ($ = dt),
+                    M)
+                  ) {
+                    case 1:
+                      var b = -1
+                      break
+                    case 2:
+                      b = 250
+                      break
+                    case 5:
+                      b = 1073741823
+                      break
+                    case 4:
+                      b = 1e4
+                      break
+                    default:
+                      b = 5e3
+                  }
+                  return (
+                    (b = $ + b),
+                    (M = {
+                      id: E++,
+                      callback: _,
+                      priorityLevel: M,
+                      startTime: $,
+                      expirationTime: b,
+                      sortIndex: -1,
+                    }),
+                    $ > dt
+                      ? ((M.sortIndex = $),
+                        i(A, M),
+                        c(v) === null &&
+                          M === c(A) &&
+                          (x ? (D(G), (G = -1)) : (x = !0), at(V, $ - dt)))
+                      : ((M.sortIndex = b),
+                        i(v, M),
+                        N || z || ((N = !0), j || ((j = !0), et()))),
+                    M
+                  )
+                }),
+                (u.unstable_shouldYield = F),
+                (u.unstable_wrapCallback = function (M) {
+                  var _ = R
+                  return function () {
+                    var $ = R
+                    R = _
+                    try {
+                      return M.apply(this, arguments)
+                    } finally {
+                      R = $
+                    }
+                  }
+                }))
+            })(Uf)),
+          Uf
+        )
+      }
+      var r2
+      function g5() {
+        return (r2 || ((r2 = 1), (Bf.exports = h5())), Bf.exports)
+      }
+      var Qf = { exports: {} },
+        le = {}
+      /**
+       * @license React
+       * react-dom.production.js
+       *
+       * Copyright (c) Meta Platforms, Inc. and affiliates.
+       *
+       * This source code is licensed under the MIT license found in the
+       * LICENSE file in the root directory of this source tree.
+       */ var o2
+      function m5() {
+        if (o2) return le
+        o2 = 1
+        var u = dr()
+        function i(v) {
+          var A = 'https://react.dev/errors/' + v
+          if (1 < arguments.length) {
+            A += '?args[]=' + encodeURIComponent(arguments[1])
+            for (var E = 2; E < arguments.length; E++)
+              A += '&args[]=' + encodeURIComponent(arguments[E])
+          }
+          return (
+            'Minified React error #' +
+            v +
+            '; visit ' +
+            A +
+            ' for the full message or use the non-minified dev environment for full errors and additional helpful warnings.'
+          )
+        }
+        function c() {}
+        var f = {
+            d: {
+              f: c,
+              r: function () {
+                throw Error(i(522))
+              },
+              D: c,
+              C: c,
+              L: c,
+              m: c,
+              X: c,
+              S: c,
+              M: c,
+            },
+            p: 0,
+            findDOMNode: null,
+          },
+          r = Symbol.for('react.portal')
+        function o(v, A, E) {
+          var w =
+            3 < arguments.length && arguments[3] !== void 0
+              ? arguments[3]
+              : null
+          return {
+            $$typeof: r,
+            key: w == null ? null : '' + w,
+            children: v,
+            containerInfo: A,
+            implementation: E,
+          }
+        }
+        var d =
+          u.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE
+        function y(v, A) {
+          if (v === 'font') return ''
+          if (typeof A == 'string') return A === 'use-credentials' ? A : ''
+        }
+        return (
+          (le.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = f),
+          (le.createPortal = function (v, A) {
+            var E =
+              2 < arguments.length && arguments[2] !== void 0
+                ? arguments[2]
+                : null
+            if (
+              !A ||
+              (A.nodeType !== 1 && A.nodeType !== 9 && A.nodeType !== 11)
+            )
+              throw Error(i(299))
+            return o(v, A, null, E)
+          }),
+          (le.flushSync = function (v) {
+            var A = d.T,
+              E = f.p
+            try {
+              if (((d.T = null), (f.p = 2), v)) return v()
+            } finally {
+              ;((d.T = A), (f.p = E), f.d.f())
+            }
+          }),
+          (le.preconnect = function (v, A) {
+            typeof v == 'string' &&
+              (A
+                ? ((A = A.crossOrigin),
+                  (A =
+                    typeof A == 'string'
+                      ? A === 'use-credentials'
+                        ? A
+                        : ''
+                      : void 0))
+                : (A = null),
+              f.d.C(v, A))
+          }),
+          (le.prefetchDNS = function (v) {
+            typeof v == 'string' && f.d.D(v)
+          }),
+          (le.preinit = function (v, A) {
+            if (typeof v == 'string' && A && typeof A.as == 'string') {
+              var E = A.as,
+                w = y(E, A.crossOrigin),
+                R = typeof A.integrity == 'string' ? A.integrity : void 0,
+                z =
+                  typeof A.fetchPriority == 'string' ? A.fetchPriority : void 0
+              E === 'style'
+                ? f.d.S(
+                    v,
+                    typeof A.precedence == 'string' ? A.precedence : void 0,
+                    { crossOrigin: w, integrity: R, fetchPriority: z },
+                  )
+                : E === 'script' &&
+                  f.d.X(v, {
+                    crossOrigin: w,
+                    integrity: R,
+                    fetchPriority: z,
+                    nonce: typeof A.nonce == 'string' ? A.nonce : void 0,
+                  })
+            }
+          }),
+          (le.preinitModule = function (v, A) {
+            if (typeof v == 'string')
+              if (typeof A == 'object' && A !== null) {
+                if (A.as == null || A.as === 'script') {
+                  var E = y(A.as, A.crossOrigin)
+                  f.d.M(v, {
+                    crossOrigin: E,
+                    integrity:
+                      typeof A.integrity == 'string' ? A.integrity : void 0,
+                    nonce: typeof A.nonce == 'string' ? A.nonce : void 0,
+                  })
+                }
+              } else A == null && f.d.M(v)
+          }),
+          (le.preload = function (v, A) {
+            if (
+              typeof v == 'string' &&
+              typeof A == 'object' &&
+              A !== null &&
+              typeof A.as == 'string'
+            ) {
+              var E = A.as,
+                w = y(E, A.crossOrigin)
+              f.d.L(v, E, {
+                crossOrigin: w,
+                integrity:
+                  typeof A.integrity == 'string' ? A.integrity : void 0,
+                nonce: typeof A.nonce == 'string' ? A.nonce : void 0,
+                type: typeof A.type == 'string' ? A.type : void 0,
+                fetchPriority:
+                  typeof A.fetchPriority == 'string' ? A.fetchPriority : void 0,
+                referrerPolicy:
+                  typeof A.referrerPolicy == 'string'
+                    ? A.referrerPolicy
+                    : void 0,
+                imageSrcSet:
+                  typeof A.imageSrcSet == 'string' ? A.imageSrcSet : void 0,
+                imageSizes:
+                  typeof A.imageSizes == 'string' ? A.imageSizes : void 0,
+                media: typeof A.media == 'string' ? A.media : void 0,
+              })
+            }
+          }),
+          (le.preloadModule = function (v, A) {
+            if (typeof v == 'string')
+              if (A) {
+                var E = y(A.as, A.crossOrigin)
+                f.d.m(v, {
+                  as:
+                    typeof A.as == 'string' && A.as !== 'script'
+                      ? A.as
+                      : void 0,
+                  crossOrigin: E,
+                  integrity:
+                    typeof A.integrity == 'string' ? A.integrity : void 0,
+                })
+              } else f.d.m(v)
+          }),
+          (le.requestFormReset = function (v) {
+            f.d.r(v)
+          }),
+          (le.unstable_batchedUpdates = function (v, A) {
+            return v(A)
+          }),
+          (le.useFormState = function (v, A, E) {
+            return d.H.useFormState(v, A, E)
+          }),
+          (le.useFormStatus = function () {
+            return d.H.useHostTransitionStatus()
+          }),
+          (le.version = '19.1.1'),
+          le
+        )
+      }
+      var d2
+      function A5() {
+        if (d2) return Qf.exports
+        d2 = 1
+        function u() {
+          if (
+            !(
+              typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ > 'u' ||
+              typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE != 'function'
+            )
+          )
+            try {
+              __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(u)
+            } catch (i) {
+              console.error(i)
+            }
+        }
+        return (u(), (Qf.exports = m5()), Qf.exports)
+      }
+      /**
+       * @license React
+       * react-dom-client.production.js
+       *
+       * Copyright (c) Meta Platforms, Inc. and affiliates.
+       *
+       * This source code is licensed under the MIT license found in the
+       * LICENSE file in the root directory of this source tree.
+       */ var h2
+      function v5() {
+        if (h2) return Ei
+        h2 = 1
+        var u = g5(),
+          i = dr(),
+          c = A5()
+        function f(t) {
+          var e = 'https://react.dev/errors/' + t
+          if (1 < arguments.length) {
+            e += '?args[]=' + encodeURIComponent(arguments[1])
+            for (var n = 2; n < arguments.length; n++)
+              e += '&args[]=' + encodeURIComponent(arguments[n])
+          }
+          return (
+            'Minified React error #' +
+            t +
+            '; visit ' +
+            e +
+            ' for the full message or use the non-minified dev environment for full errors and additional helpful warnings.'
+          )
+        }
+        function r(t) {
+          return !(
+            !t ||
+            (t.nodeType !== 1 && t.nodeType !== 9 && t.nodeType !== 11)
+          )
+        }
+        function o(t) {
+          var e = t,
+            n = t
+          if (t.alternate) for (; e.return; ) e = e.return
+          else {
+            t = e
+            do
+              ((e = t),
+                (e.flags & 4098) !== 0 && (n = e.return),
+                (t = e.return))
+            while (t)
+          }
+          return e.tag === 3 ? n : null
+        }
+        function d(t) {
+          if (t.tag === 13) {
+            var e = t.memoizedState
+            if (
+              (e === null &&
+                ((t = t.alternate), t !== null && (e = t.memoizedState)),
+              e !== null)
+            )
+              return e.dehydrated
+          }
+          return null
+        }
+        function y(t) {
+          if (o(t) !== t) throw Error(f(188))
+        }
+        function v(t) {
+          var e = t.alternate
+          if (!e) {
+            if (((e = o(t)), e === null)) throw Error(f(188))
+            return e !== t ? null : t
+          }
+          for (var n = t, a = e; ; ) {
+            var l = n.return
+            if (l === null) break
+            var s = l.alternate
+            if (s === null) {
+              if (((a = l.return), a !== null)) {
+                n = a
+                continue
+              }
+              break
+            }
+            if (l.child === s.child) {
+              for (s = l.child; s; ) {
+                if (s === n) return (y(l), t)
+                if (s === a) return (y(l), e)
+                s = s.sibling
+              }
+              throw Error(f(188))
+            }
+            if (n.return !== a.return) ((n = l), (a = s))
+            else {
+              for (var h = !1, g = l.child; g; ) {
+                if (g === n) {
+                  ;((h = !0), (n = l), (a = s))
+                  break
+                }
+                if (g === a) {
+                  ;((h = !0), (a = l), (n = s))
+                  break
+                }
+                g = g.sibling
+              }
+              if (!h) {
+                for (g = s.child; g; ) {
+                  if (g === n) {
+                    ;((h = !0), (n = s), (a = l))
+                    break
+                  }
+                  if (g === a) {
+                    ;((h = !0), (a = s), (n = l))
+                    break
+                  }
+                  g = g.sibling
+                }
+                if (!h) throw Error(f(189))
+              }
+            }
+            if (n.alternate !== a) throw Error(f(190))
+          }
+          if (n.tag !== 3) throw Error(f(188))
+          return n.stateNode.current === n ? t : e
+        }
+        function A(t) {
+          var e = t.tag
+          if (e === 5 || e === 26 || e === 27 || e === 6) return t
+          for (t = t.child; t !== null; ) {
+            if (((e = A(t)), e !== null)) return e
+            t = t.sibling
+          }
+          return null
+        }
+        var E = Object.assign,
+          w = Symbol.for('react.element'),
+          R = Symbol.for('react.transitional.element'),
+          z = Symbol.for('react.portal'),
+          N = Symbol.for('react.fragment'),
+          x = Symbol.for('react.strict_mode'),
+          p = Symbol.for('react.profiler'),
+          T = Symbol.for('react.provider'),
+          D = Symbol.for('react.consumer'),
+          U = Symbol.for('react.context'),
+          I = Symbol.for('react.forward_ref'),
+          V = Symbol.for('react.suspense'),
+          j = Symbol.for('react.suspense_list'),
+          G = Symbol.for('react.memo'),
+          L = Symbol.for('react.lazy'),
+          W = Symbol.for('react.activity'),
+          F = Symbol.for('react.memo_cache_sentinel'),
+          K = Symbol.iterator
+        function et(t) {
+          return t === null || typeof t != 'object'
+            ? null
+            : ((t = (K && t[K]) || t['@@iterator']),
+              typeof t == 'function' ? t : null)
+        }
+        var tt = Symbol.for('react.client.reference')
+        function ot(t) {
+          if (t == null) return null
+          if (typeof t == 'function')
+            return t.$$typeof === tt ? null : t.displayName || t.name || null
+          if (typeof t == 'string') return t
+          switch (t) {
+            case N:
+              return 'Fragment'
+            case p:
+              return 'Profiler'
+            case x:
+              return 'StrictMode'
+            case V:
+              return 'Suspense'
+            case j:
+              return 'SuspenseList'
+            case W:
+              return 'Activity'
+          }
+          if (typeof t == 'object')
+            switch (t.$$typeof) {
+              case z:
+                return 'Portal'
+              case U:
+                return (t.displayName || 'Context') + '.Provider'
+              case D:
+                return (t._context.displayName || 'Context') + '.Consumer'
+              case I:
+                var e = t.render
+                return (
+                  (t = t.displayName),
+                  t ||
+                    ((t = e.displayName || e.name || ''),
+                    (t = t !== '' ? 'ForwardRef(' + t + ')' : 'ForwardRef')),
+                  t
+                )
+              case G:
+                return (
+                  (e = t.displayName || null),
+                  e !== null ? e : ot(t.type) || 'Memo'
+                )
+              case L:
+                ;((e = t._payload), (t = t._init))
+                try {
+                  return ot(t(e))
+                } catch {}
+            }
+          return null
+        }
+        var at = Array.isArray,
+          M = i.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+          _ = c.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+          $ = { pending: !1, data: null, method: null, action: null },
+          dt = [],
+          b = -1
+        function q(t) {
+          return { current: t }
+        }
+        function P(t) {
+          0 > b || ((t.current = dt[b]), (dt[b] = null), b--)
+        }
+        function J(t, e) {
+          ;(b++, (dt[b] = t.current), (t.current = e))
+        }
+        var it = q(null),
+          mt = q(null),
+          ut = q(null),
+          Nt = q(null)
+        function Dt(t, e) {
+          switch ((J(ut, e), J(mt, t), J(it, null), e.nodeType)) {
+            case 9:
+            case 11:
+              t = (t = e.documentElement) && (t = t.namespaceURI) ? Gd(t) : 0
+              break
+            default:
+              if (((t = e.tagName), (e = e.namespaceURI)))
+                ((e = Gd(e)), (t = Xd(e, t)))
+              else
+                switch (t) {
+                  case 'svg':
+                    t = 1
+                    break
+                  case 'math':
+                    t = 2
+                    break
+                  default:
+                    t = 0
+                }
+          }
+          ;(P(it), J(it, t))
+        }
+        function Le() {
+          ;(P(it), P(mt), P(ut))
+        }
+        function Ra(t) {
+          t.memoizedState !== null && J(Nt, t)
+          var e = it.current,
+            n = Xd(e, t.type)
+          e !== n && (J(mt, t), J(it, n))
+        }
+        function ea(t) {
+          ;(mt.current === t && (P(it), P(mt)),
+            Nt.current === t && (P(Nt), (oi._currentValue = $)))
+        }
+        var bn = Object.prototype.hasOwnProperty,
+          na = u.unstable_scheduleCallback,
+          Fe = u.unstable_cancelCallback,
+          ji = u.unstable_shouldYield,
+          Oa = u.unstable_requestPaint,
+          ce = u.unstable_now,
+          sc = u.unstable_getCurrentPriorityLevel,
+          Er = u.unstable_ImmediatePriority,
+          br = u.unstable_UserBlockingPriority,
+          Hi = u.unstable_NormalPriority,
+          kh = u.unstable_LowPriority,
+          pr = u.unstable_IdlePriority,
+          Kh = u.log,
+          Wh = u.unstable_setDisableYieldValue,
+          El = null,
+          Ae = null
+        function pn(t) {
+          if (
+            (typeof Kh == 'function' && Wh(t),
+            Ae && typeof Ae.setStrictMode == 'function')
+          )
+            try {
+              Ae.setStrictMode(El, t)
+            } catch {}
+        }
+        var ve = Math.clz32 ? Math.clz32 : Ph,
+          Fh = Math.log,
+          Jh = Math.LN2
+        function Ph(t) {
+          return ((t >>>= 0), t === 0 ? 32 : (31 - ((Fh(t) / Jh) | 0)) | 0)
+        }
+        var Ni = 256,
+          Bi = 4194304
+        function aa(t) {
+          var e = t & 42
+          if (e !== 0) return e
+          switch (t & -t) {
+            case 1:
+              return 1
+            case 2:
+              return 2
+            case 4:
+              return 4
+            case 8:
+              return 8
+            case 16:
+              return 16
+            case 32:
+              return 32
+            case 64:
+              return 64
+            case 128:
+              return 128
+            case 256:
+            case 512:
+            case 1024:
+            case 2048:
+            case 4096:
+            case 8192:
+            case 16384:
+            case 32768:
+            case 65536:
+            case 131072:
+            case 262144:
+            case 524288:
+            case 1048576:
+            case 2097152:
+              return t & 4194048
+            case 4194304:
+            case 8388608:
+            case 16777216:
+            case 33554432:
+              return t & 62914560
+            case 67108864:
+              return 67108864
+            case 134217728:
+              return 134217728
+            case 268435456:
+              return 268435456
+            case 536870912:
+              return 536870912
+            case 1073741824:
+              return 0
+            default:
+              return t
+          }
+        }
+        function Ui(t, e, n) {
+          var a = t.pendingLanes
+          if (a === 0) return 0
+          var l = 0,
+            s = t.suspendedLanes,
+            h = t.pingedLanes
+          t = t.warmLanes
+          var g = a & 134217727
+          return (
+            g !== 0
+              ? ((a = g & ~s),
+                a !== 0
+                  ? (l = aa(a))
+                  : ((h &= g),
+                    h !== 0
+                      ? (l = aa(h))
+                      : n || ((n = g & ~t), n !== 0 && (l = aa(n)))))
+              : ((g = a & ~s),
+                g !== 0
+                  ? (l = aa(g))
+                  : h !== 0
+                    ? (l = aa(h))
+                    : n || ((n = a & ~t), n !== 0 && (l = aa(n)))),
+            l === 0
+              ? 0
+              : e !== 0 &&
+                  e !== l &&
+                  (e & s) === 0 &&
+                  ((s = l & -l),
+                  (n = e & -e),
+                  s >= n || (s === 32 && (n & 4194048) !== 0))
+                ? e
+                : l
+          )
+        }
+        function bl(t, e) {
+          return (
+            (t.pendingLanes & ~(t.suspendedLanes & ~t.pingedLanes) & e) === 0
+          )
+        }
+        function _h(t, e) {
+          switch (t) {
+            case 1:
+            case 2:
+            case 4:
+            case 8:
+            case 64:
+              return e + 250
+            case 16:
+            case 32:
+            case 128:
+            case 256:
+            case 512:
+            case 1024:
+            case 2048:
+            case 4096:
+            case 8192:
+            case 16384:
+            case 32768:
+            case 65536:
+            case 131072:
+            case 262144:
+            case 524288:
+            case 1048576:
+            case 2097152:
+              return e + 5e3
+            case 4194304:
+            case 8388608:
+            case 16777216:
+            case 33554432:
+              return -1
+            case 67108864:
+            case 134217728:
+            case 268435456:
+            case 536870912:
+            case 1073741824:
+              return -1
+            default:
+              return -1
+          }
+        }
+        function xr() {
+          var t = Ni
+          return ((Ni <<= 1), (Ni & 4194048) === 0 && (Ni = 256), t)
+        }
+        function Sr() {
+          var t = Bi
+          return ((Bi <<= 1), (Bi & 62914560) === 0 && (Bi = 4194304), t)
+        }
+        function fc(t) {
+          for (var e = [], n = 0; 31 > n; n++) e.push(t)
+          return e
+        }
+        function pl(t, e) {
+          ;((t.pendingLanes |= e),
+            e !== 268435456 &&
+              ((t.suspendedLanes = 0), (t.pingedLanes = 0), (t.warmLanes = 0)))
+        }
+        function $h(t, e, n, a, l, s) {
+          var h = t.pendingLanes
+          ;((t.pendingLanes = n),
+            (t.suspendedLanes = 0),
+            (t.pingedLanes = 0),
+            (t.warmLanes = 0),
+            (t.expiredLanes &= n),
+            (t.entangledLanes &= n),
+            (t.errorRecoveryDisabledLanes &= n),
+            (t.shellSuspendCounter = 0))
+          var g = t.entanglements,
+            S = t.expirationTimes,
+            B = t.hiddenUpdates
+          for (n = h & ~n; 0 < n; ) {
+            var X = 31 - ve(n),
+              k = 1 << X
+            ;((g[X] = 0), (S[X] = -1))
+            var Q = B[X]
+            if (Q !== null)
+              for (B[X] = null, X = 0; X < Q.length; X++) {
+                var Y = Q[X]
+                Y !== null && (Y.lane &= -536870913)
+              }
+            n &= ~k
+          }
+          ;(a !== 0 && Tr(t, a, 0),
+            s !== 0 &&
+              l === 0 &&
+              t.tag !== 0 &&
+              (t.suspendedLanes |= s & ~(h & ~e)))
+        }
+        function Tr(t, e, n) {
+          ;((t.pendingLanes |= e), (t.suspendedLanes &= ~e))
+          var a = 31 - ve(e)
+          ;((t.entangledLanes |= e),
+            (t.entanglements[a] =
+              t.entanglements[a] | 1073741824 | (n & 4194090)))
+        }
+        function wr(t, e) {
+          var n = (t.entangledLanes |= e)
+          for (t = t.entanglements; n; ) {
+            var a = 31 - ve(n),
+              l = 1 << a
+            ;((l & e) | (t[a] & e) && (t[a] |= e), (n &= ~l))
+          }
+        }
+        function rc(t) {
+          switch (t) {
+            case 2:
+              t = 1
+              break
+            case 8:
+              t = 4
+              break
+            case 32:
+              t = 16
+              break
+            case 256:
+            case 512:
+            case 1024:
+            case 2048:
+            case 4096:
+            case 8192:
+            case 16384:
+            case 32768:
+            case 65536:
+            case 131072:
+            case 262144:
+            case 524288:
+            case 1048576:
+            case 2097152:
+            case 4194304:
+            case 8388608:
+            case 16777216:
+            case 33554432:
+              t = 128
+              break
+            case 268435456:
+              t = 134217728
+              break
+            default:
+              t = 0
+          }
+          return t
+        }
+        function oc(t) {
+          return (
+            (t &= -t),
+            2 < t ? (8 < t ? ((t & 134217727) !== 0 ? 32 : 268435456) : 8) : 2
+          )
+        }
+        function Rr() {
+          var t = _.p
+          return t !== 0
+            ? t
+            : ((t = window.event), t === void 0 ? 32 : u1(t.type))
+        }
+        function tg(t, e) {
+          var n = _.p
+          try {
+            return ((_.p = t), e())
+          } finally {
+            _.p = n
+          }
+        }
+        var xn = Math.random().toString(36).slice(2),
+          ne = '__reactFiber$' + xn,
+          re = '__reactProps$' + xn,
+          Da = '__reactContainer$' + xn,
+          dc = '__reactEvents$' + xn,
+          eg = '__reactListeners$' + xn,
+          ng = '__reactHandles$' + xn,
+          Or = '__reactResources$' + xn,
+          xl = '__reactMarker$' + xn
+        function hc(t) {
+          ;(delete t[ne],
+            delete t[re],
+            delete t[dc],
+            delete t[eg],
+            delete t[ng])
+        }
+        function Ca(t) {
+          var e = t[ne]
+          if (e) return e
+          for (var n = t.parentNode; n; ) {
+            if ((e = n[Da] || n[ne])) {
+              if (
+                ((n = e.alternate),
+                e.child !== null || (n !== null && n.child !== null))
+              )
+                for (t = qd(t); t !== null; ) {
+                  if ((n = t[ne])) return n
+                  t = qd(t)
+                }
+              return e
+            }
+            ;((t = n), (n = t.parentNode))
+          }
+          return null
+        }
+        function Ma(t) {
+          if ((t = t[ne] || t[Da])) {
+            var e = t.tag
+            if (
+              e === 5 ||
+              e === 6 ||
+              e === 13 ||
+              e === 26 ||
+              e === 27 ||
+              e === 3
+            )
+              return t
+          }
+          return null
+        }
+        function Sl(t) {
+          var e = t.tag
+          if (e === 5 || e === 26 || e === 27 || e === 6) return t.stateNode
+          throw Error(f(33))
+        }
+        function ja(t) {
+          var e = t[Or]
+          return (
+            e ||
+              (e = t[Or] =
+                { hoistableStyles: new Map(), hoistableScripts: new Map() }),
+            e
+          )
+        }
+        function kt(t) {
+          t[xl] = !0
+        }
+        var Dr = new Set(),
+          Cr = {}
+        function la(t, e) {
+          ;(Ha(t, e), Ha(t + 'Capture', e))
+        }
+        function Ha(t, e) {
+          for (Cr[t] = e, t = 0; t < e.length; t++) Dr.add(e[t])
+        }
+        var ag = RegExp(
+            '^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$',
+          ),
+          Mr = {},
+          jr = {}
+        function lg(t) {
+          return bn.call(jr, t)
+            ? !0
+            : bn.call(Mr, t)
+              ? !1
+              : ag.test(t)
+                ? (jr[t] = !0)
+                : ((Mr[t] = !0), !1)
+        }
+        function Qi(t, e, n) {
+          if (lg(e))
+            if (n === null) t.removeAttribute(e)
+            else {
+              switch (typeof n) {
+                case 'undefined':
+                case 'function':
+                case 'symbol':
+                  t.removeAttribute(e)
+                  return
+                case 'boolean':
+                  var a = e.toLowerCase().slice(0, 5)
+                  if (a !== 'data-' && a !== 'aria-') {
+                    t.removeAttribute(e)
+                    return
+                  }
+              }
+              t.setAttribute(e, '' + n)
+            }
+        }
+        function Yi(t, e, n) {
+          if (n === null) t.removeAttribute(e)
+          else {
+            switch (typeof n) {
+              case 'undefined':
+              case 'function':
+              case 'symbol':
+              case 'boolean':
+                t.removeAttribute(e)
+                return
+            }
+            t.setAttribute(e, '' + n)
+          }
+        }
+        function Je(t, e, n, a) {
+          if (a === null) t.removeAttribute(n)
+          else {
+            switch (typeof a) {
+              case 'undefined':
+              case 'function':
+              case 'symbol':
+              case 'boolean':
+                t.removeAttribute(n)
+                return
+            }
+            t.setAttributeNS(e, n, '' + a)
+          }
+        }
+        var gc, Hr
+        function Na(t) {
+          if (gc === void 0)
+            try {
+              throw Error()
+            } catch (n) {
+              var e = n.stack.trim().match(/\n( *(at )?)/)
+              ;((gc = (e && e[1]) || ''),
+                (Hr =
+                  -1 <
+                  n.stack.indexOf(`
+    at`)
+                    ? ' (<anonymous>)'
+                    : -1 < n.stack.indexOf('@')
+                      ? '@unknown:0:0'
+                      : ''))
+            }
+          return (
+            `
+` +
+            gc +
+            t +
+            Hr
+          )
+        }
+        var mc = !1
+        function Ac(t, e) {
+          if (!t || mc) return ''
+          mc = !0
+          var n = Error.prepareStackTrace
+          Error.prepareStackTrace = void 0
+          try {
+            var a = {
+              DetermineComponentFrameRoot: function () {
+                try {
+                  if (e) {
+                    var k = function () {
+                      throw Error()
+                    }
+                    if (
+                      (Object.defineProperty(k.prototype, 'props', {
+                        set: function () {
+                          throw Error()
+                        },
+                      }),
+                      typeof Reflect == 'object' && Reflect.construct)
+                    ) {
+                      try {
+                        Reflect.construct(k, [])
+                      } catch (Y) {
+                        var Q = Y
+                      }
+                      Reflect.construct(t, [], k)
+                    } else {
+                      try {
+                        k.call()
+                      } catch (Y) {
+                        Q = Y
+                      }
+                      t.call(k.prototype)
+                    }
+                  } else {
+                    try {
+                      throw Error()
+                    } catch (Y) {
+                      Q = Y
+                    }
+                    ;(k = t()) &&
+                      typeof k.catch == 'function' &&
+                      k.catch(function () {})
+                  }
+                } catch (Y) {
+                  if (Y && Q && typeof Y.stack == 'string')
+                    return [Y.stack, Q.stack]
+                }
+                return [null, null]
+              },
+            }
+            a.DetermineComponentFrameRoot.displayName =
+              'DetermineComponentFrameRoot'
+            var l = Object.getOwnPropertyDescriptor(
+              a.DetermineComponentFrameRoot,
+              'name',
+            )
+            l &&
+              l.configurable &&
+              Object.defineProperty(a.DetermineComponentFrameRoot, 'name', {
+                value: 'DetermineComponentFrameRoot',
+              })
+            var s = a.DetermineComponentFrameRoot(),
+              h = s[0],
+              g = s[1]
+            if (h && g) {
+              var S = h.split(`
+`),
+                B = g.split(`
+`)
+              for (
+                l = a = 0;
+                a < S.length && !S[a].includes('DetermineComponentFrameRoot');
+              )
+                a++
+              for (
+                ;
+                l < B.length && !B[l].includes('DetermineComponentFrameRoot');
+              )
+                l++
+              if (a === S.length || l === B.length)
+                for (
+                  a = S.length - 1, l = B.length - 1;
+                  1 <= a && 0 <= l && S[a] !== B[l];
+                )
+                  l--
+              for (; 1 <= a && 0 <= l; a--, l--)
+                if (S[a] !== B[l]) {
+                  if (a !== 1 || l !== 1)
+                    do
+                      if ((a--, l--, 0 > l || S[a] !== B[l])) {
+                        var X =
+                          `
+` + S[a].replace(' at new ', ' at ')
+                        return (
+                          t.displayName &&
+                            X.includes('<anonymous>') &&
+                            (X = X.replace('<anonymous>', t.displayName)),
+                          X
+                        )
+                      }
+                    while (1 <= a && 0 <= l)
+                  break
+                }
+            }
+          } finally {
+            ;((mc = !1), (Error.prepareStackTrace = n))
+          }
+          return (n = t ? t.displayName || t.name : '') ? Na(n) : ''
+        }
+        function ig(t) {
+          switch (t.tag) {
+            case 26:
+            case 27:
+            case 5:
+              return Na(t.type)
+            case 16:
+              return Na('Lazy')
+            case 13:
+              return Na('Suspense')
+            case 19:
+              return Na('SuspenseList')
+            case 0:
+            case 15:
+              return Ac(t.type, !1)
+            case 11:
+              return Ac(t.type.render, !1)
+            case 1:
+              return Ac(t.type, !0)
+            case 31:
+              return Na('Activity')
+            default:
+              return ''
+          }
+        }
+        function Nr(t) {
+          try {
+            var e = ''
+            do ((e += ig(t)), (t = t.return))
+            while (t)
+            return e
+          } catch (n) {
+            return (
+              `
+Error generating stack: ` +
+              n.message +
+              `
+` +
+              n.stack
+            )
+          }
+        }
+        function Re(t) {
+          switch (typeof t) {
+            case 'bigint':
+            case 'boolean':
+            case 'number':
+            case 'string':
+            case 'undefined':
+              return t
+            case 'object':
+              return t
+            default:
+              return ''
+          }
+        }
+        function Br(t) {
+          var e = t.type
+          return (
+            (t = t.nodeName) &&
+            t.toLowerCase() === 'input' &&
+            (e === 'checkbox' || e === 'radio')
+          )
+        }
+        function ug(t) {
+          var e = Br(t) ? 'checked' : 'value',
+            n = Object.getOwnPropertyDescriptor(t.constructor.prototype, e),
+            a = '' + t[e]
+          if (
+            !t.hasOwnProperty(e) &&
+            typeof n < 'u' &&
+            typeof n.get == 'function' &&
+            typeof n.set == 'function'
+          ) {
+            var l = n.get,
+              s = n.set
+            return (
+              Object.defineProperty(t, e, {
+                configurable: !0,
+                get: function () {
+                  return l.call(this)
+                },
+                set: function (h) {
+                  ;((a = '' + h), s.call(this, h))
+                },
+              }),
+              Object.defineProperty(t, e, { enumerable: n.enumerable }),
+              {
+                getValue: function () {
+                  return a
+                },
+                setValue: function (h) {
+                  a = '' + h
+                },
+                stopTracking: function () {
+                  ;((t._valueTracker = null), delete t[e])
+                },
+              }
+            )
+          }
+        }
+        function Li(t) {
+          t._valueTracker || (t._valueTracker = ug(t))
+        }
+        function Ur(t) {
+          if (!t) return !1
+          var e = t._valueTracker
+          if (!e) return !0
+          var n = e.getValue(),
+            a = ''
+          return (
+            t && (a = Br(t) ? (t.checked ? 'true' : 'false') : t.value),
+            (t = a),
+            t !== n ? (e.setValue(t), !0) : !1
+          )
+        }
+        function zi(t) {
+          if (
+            ((t = t || (typeof document < 'u' ? document : void 0)),
+            typeof t > 'u')
+          )
+            return null
+          try {
+            return t.activeElement || t.body
+          } catch {
+            return t.body
+          }
+        }
+        var cg = /[\n"\\]/g
+        function Oe(t) {
+          return t.replace(cg, function (e) {
+            return '\\' + e.charCodeAt(0).toString(16) + ' '
+          })
+        }
+        function vc(t, e, n, a, l, s, h, g) {
+          ;((t.name = ''),
+            h != null &&
+            typeof h != 'function' &&
+            typeof h != 'symbol' &&
+            typeof h != 'boolean'
+              ? (t.type = h)
+              : t.removeAttribute('type'),
+            e != null
+              ? h === 'number'
+                ? ((e === 0 && t.value === '') || t.value != e) &&
+                  (t.value = '' + Re(e))
+                : t.value !== '' + Re(e) && (t.value = '' + Re(e))
+              : (h !== 'submit' && h !== 'reset') || t.removeAttribute('value'),
+            e != null
+              ? yc(t, h, Re(e))
+              : n != null
+                ? yc(t, h, Re(n))
+                : a != null && t.removeAttribute('value'),
+            l == null && s != null && (t.defaultChecked = !!s),
+            l != null &&
+              (t.checked = l && typeof l != 'function' && typeof l != 'symbol'),
+            g != null &&
+            typeof g != 'function' &&
+            typeof g != 'symbol' &&
+            typeof g != 'boolean'
+              ? (t.name = '' + Re(g))
+              : t.removeAttribute('name'))
+        }
+        function Qr(t, e, n, a, l, s, h, g) {
+          if (
+            (s != null &&
+              typeof s != 'function' &&
+              typeof s != 'symbol' &&
+              typeof s != 'boolean' &&
+              (t.type = s),
+            e != null || n != null)
+          ) {
+            if (!((s !== 'submit' && s !== 'reset') || e != null)) return
+            ;((n = n != null ? '' + Re(n) : ''),
+              (e = e != null ? '' + Re(e) : n),
+              g || e === t.value || (t.value = e),
+              (t.defaultValue = e))
+          }
+          ;((a = a ?? l),
+            (a = typeof a != 'function' && typeof a != 'symbol' && !!a),
+            (t.checked = g ? t.checked : !!a),
+            (t.defaultChecked = !!a),
+            h != null &&
+              typeof h != 'function' &&
+              typeof h != 'symbol' &&
+              typeof h != 'boolean' &&
+              (t.name = h))
+        }
+        function yc(t, e, n) {
+          ;(e === 'number' && zi(t.ownerDocument) === t) ||
+            t.defaultValue === '' + n ||
+            (t.defaultValue = '' + n)
+        }
+        function Ba(t, e, n, a) {
+          if (((t = t.options), e)) {
+            e = {}
+            for (var l = 0; l < n.length; l++) e['$' + n[l]] = !0
+            for (n = 0; n < t.length; n++)
+              ((l = e.hasOwnProperty('$' + t[n].value)),
+                t[n].selected !== l && (t[n].selected = l),
+                l && a && (t[n].defaultSelected = !0))
+          } else {
+            for (n = '' + Re(n), e = null, l = 0; l < t.length; l++) {
+              if (t[l].value === n) {
+                ;((t[l].selected = !0), a && (t[l].defaultSelected = !0))
+                return
+              }
+              e !== null || t[l].disabled || (e = t[l])
+            }
+            e !== null && (e.selected = !0)
+          }
+        }
+        function Yr(t, e, n) {
+          if (
+            e != null &&
+            ((e = '' + Re(e)), e !== t.value && (t.value = e), n == null)
+          ) {
+            t.defaultValue !== e && (t.defaultValue = e)
+            return
+          }
+          t.defaultValue = n != null ? '' + Re(n) : ''
+        }
+        function Lr(t, e, n, a) {
+          if (e == null) {
+            if (a != null) {
+              if (n != null) throw Error(f(92))
+              if (at(a)) {
+                if (1 < a.length) throw Error(f(93))
+                a = a[0]
+              }
+              n = a
+            }
+            ;(n == null && (n = ''), (e = n))
+          }
+          ;((n = Re(e)),
+            (t.defaultValue = n),
+            (a = t.textContent),
+            a === n && a !== '' && a !== null && (t.value = a))
+        }
+        function Ua(t, e) {
+          if (e) {
+            var n = t.firstChild
+            if (n && n === t.lastChild && n.nodeType === 3) {
+              n.nodeValue = e
+              return
+            }
+          }
+          t.textContent = e
+        }
+        var sg = new Set(
+          'animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp'.split(
+            ' ',
+          ),
+        )
+        function zr(t, e, n) {
+          var a = e.indexOf('--') === 0
+          n == null || typeof n == 'boolean' || n === ''
+            ? a
+              ? t.setProperty(e, '')
+              : e === 'float'
+                ? (t.cssFloat = '')
+                : (t[e] = '')
+            : a
+              ? t.setProperty(e, n)
+              : typeof n != 'number' || n === 0 || sg.has(e)
+                ? e === 'float'
+                  ? (t.cssFloat = n)
+                  : (t[e] = ('' + n).trim())
+                : (t[e] = n + 'px')
+        }
+        function Gr(t, e, n) {
+          if (e != null && typeof e != 'object') throw Error(f(62))
+          if (((t = t.style), n != null)) {
+            for (var a in n)
+              !n.hasOwnProperty(a) ||
+                (e != null && e.hasOwnProperty(a)) ||
+                (a.indexOf('--') === 0
+                  ? t.setProperty(a, '')
+                  : a === 'float'
+                    ? (t.cssFloat = '')
+                    : (t[a] = ''))
+            for (var l in e)
+              ((a = e[l]), e.hasOwnProperty(l) && n[l] !== a && zr(t, l, a))
+          } else for (var s in e) e.hasOwnProperty(s) && zr(t, s, e[s])
+        }
+        function Ec(t) {
+          if (t.indexOf('-') === -1) return !1
+          switch (t) {
+            case 'annotation-xml':
+            case 'color-profile':
+            case 'font-face':
+            case 'font-face-src':
+            case 'font-face-uri':
+            case 'font-face-format':
+            case 'font-face-name':
+            case 'missing-glyph':
+              return !1
+            default:
+              return !0
+          }
+        }
+        var fg = new Map([
+            ['acceptCharset', 'accept-charset'],
+            ['htmlFor', 'for'],
+            ['httpEquiv', 'http-equiv'],
+            ['crossOrigin', 'crossorigin'],
+            ['accentHeight', 'accent-height'],
+            ['alignmentBaseline', 'alignment-baseline'],
+            ['arabicForm', 'arabic-form'],
+            ['baselineShift', 'baseline-shift'],
+            ['capHeight', 'cap-height'],
+            ['clipPath', 'clip-path'],
+            ['clipRule', 'clip-rule'],
+            ['colorInterpolation', 'color-interpolation'],
+            ['colorInterpolationFilters', 'color-interpolation-filters'],
+            ['colorProfile', 'color-profile'],
+            ['colorRendering', 'color-rendering'],
+            ['dominantBaseline', 'dominant-baseline'],
+            ['enableBackground', 'enable-background'],
+            ['fillOpacity', 'fill-opacity'],
+            ['fillRule', 'fill-rule'],
+            ['floodColor', 'flood-color'],
+            ['floodOpacity', 'flood-opacity'],
+            ['fontFamily', 'font-family'],
+            ['fontSize', 'font-size'],
+            ['fontSizeAdjust', 'font-size-adjust'],
+            ['fontStretch', 'font-stretch'],
+            ['fontStyle', 'font-style'],
+            ['fontVariant', 'font-variant'],
+            ['fontWeight', 'font-weight'],
+            ['glyphName', 'glyph-name'],
+            ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'],
+            ['glyphOrientationVertical', 'glyph-orientation-vertical'],
+            ['horizAdvX', 'horiz-adv-x'],
+            ['horizOriginX', 'horiz-origin-x'],
+            ['imageRendering', 'image-rendering'],
+            ['letterSpacing', 'letter-spacing'],
+            ['lightingColor', 'lighting-color'],
+            ['markerEnd', 'marker-end'],
+            ['markerMid', 'marker-mid'],
+            ['markerStart', 'marker-start'],
+            ['overlinePosition', 'overline-position'],
+            ['overlineThickness', 'overline-thickness'],
+            ['paintOrder', 'paint-order'],
+            ['panose-1', 'panose-1'],
+            ['pointerEvents', 'pointer-events'],
+            ['renderingIntent', 'rendering-intent'],
+            ['shapeRendering', 'shape-rendering'],
+            ['stopColor', 'stop-color'],
+            ['stopOpacity', 'stop-opacity'],
+            ['strikethroughPosition', 'strikethrough-position'],
+            ['strikethroughThickness', 'strikethrough-thickness'],
+            ['strokeDasharray', 'stroke-dasharray'],
+            ['strokeDashoffset', 'stroke-dashoffset'],
+            ['strokeLinecap', 'stroke-linecap'],
+            ['strokeLinejoin', 'stroke-linejoin'],
+            ['strokeMiterlimit', 'stroke-miterlimit'],
+            ['strokeOpacity', 'stroke-opacity'],
+            ['strokeWidth', 'stroke-width'],
+            ['textAnchor', 'text-anchor'],
+            ['textDecoration', 'text-decoration'],
+            ['textRendering', 'text-rendering'],
+            ['transformOrigin', 'transform-origin'],
+            ['underlinePosition', 'underline-position'],
+            ['underlineThickness', 'underline-thickness'],
+            ['unicodeBidi', 'unicode-bidi'],
+            ['unicodeRange', 'unicode-range'],
+            ['unitsPerEm', 'units-per-em'],
+            ['vAlphabetic', 'v-alphabetic'],
+            ['vHanging', 'v-hanging'],
+            ['vIdeographic', 'v-ideographic'],
+            ['vMathematical', 'v-mathematical'],
+            ['vectorEffect', 'vector-effect'],
+            ['vertAdvY', 'vert-adv-y'],
+            ['vertOriginX', 'vert-origin-x'],
+            ['vertOriginY', 'vert-origin-y'],
+            ['wordSpacing', 'word-spacing'],
+            ['writingMode', 'writing-mode'],
+            ['xmlnsXlink', 'xmlns:xlink'],
+            ['xHeight', 'x-height'],
+          ]),
+          rg =
+            /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i
+        function Gi(t) {
+          return rg.test('' + t)
+            ? "javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')"
+            : t
+        }
+        var bc = null
+        function pc(t) {
+          return (
+            (t = t.target || t.srcElement || window),
+            t.correspondingUseElement && (t = t.correspondingUseElement),
+            t.nodeType === 3 ? t.parentNode : t
+          )
+        }
+        var Qa = null,
+          Ya = null
+        function Xr(t) {
+          var e = Ma(t)
+          if (e && (t = e.stateNode)) {
+            var n = t[re] || null
+            t: switch (((t = e.stateNode), e.type)) {
+              case 'input':
+                if (
+                  (vc(
+                    t,
+                    n.value,
+                    n.defaultValue,
+                    n.defaultValue,
+                    n.checked,
+                    n.defaultChecked,
+                    n.type,
+                    n.name,
+                  ),
+                  (e = n.name),
+                  n.type === 'radio' && e != null)
+                ) {
+                  for (n = t; n.parentNode; ) n = n.parentNode
+                  for (
+                    n = n.querySelectorAll(
+                      'input[name="' + Oe('' + e) + '"][type="radio"]',
+                    ),
+                      e = 0;
+                    e < n.length;
+                    e++
+                  ) {
+                    var a = n[e]
+                    if (a !== t && a.form === t.form) {
+                      var l = a[re] || null
+                      if (!l) throw Error(f(90))
+                      vc(
+                        a,
+                        l.value,
+                        l.defaultValue,
+                        l.defaultValue,
+                        l.checked,
+                        l.defaultChecked,
+                        l.type,
+                        l.name,
+                      )
+                    }
+                  }
+                  for (e = 0; e < n.length; e++)
+                    ((a = n[e]), a.form === t.form && Ur(a))
+                }
+                break t
+              case 'textarea':
+                Yr(t, n.value, n.defaultValue)
+                break t
+              case 'select':
+                ;((e = n.value), e != null && Ba(t, !!n.multiple, e, !1))
+            }
+          }
+        }
+        var xc = !1
+        function Vr(t, e, n) {
+          if (xc) return t(e, n)
+          xc = !0
+          try {
+            var a = t(e)
+            return a
+          } finally {
+            if (
+              ((xc = !1),
+              (Qa !== null || Ya !== null) &&
+                (wu(), Qa && ((e = Qa), (t = Ya), (Ya = Qa = null), Xr(e), t)))
+            )
+              for (e = 0; e < t.length; e++) Xr(t[e])
+          }
+        }
+        function Tl(t, e) {
+          var n = t.stateNode
+          if (n === null) return null
+          var a = n[re] || null
+          if (a === null) return null
+          n = a[e]
+          t: switch (e) {
+            case 'onClick':
+            case 'onClickCapture':
+            case 'onDoubleClick':
+            case 'onDoubleClickCapture':
+            case 'onMouseDown':
+            case 'onMouseDownCapture':
+            case 'onMouseMove':
+            case 'onMouseMoveCapture':
+            case 'onMouseUp':
+            case 'onMouseUpCapture':
+            case 'onMouseEnter':
+              ;((a = !a.disabled) ||
+                ((t = t.type),
+                (a = !(
+                  t === 'button' ||
+                  t === 'input' ||
+                  t === 'select' ||
+                  t === 'textarea'
+                ))),
+                (t = !a))
+              break t
+            default:
+              t = !1
+          }
+          if (t) return null
+          if (n && typeof n != 'function') throw Error(f(231, e, typeof n))
+          return n
+        }
+        var Pe = !(
+            typeof window > 'u' ||
+            typeof window.document > 'u' ||
+            typeof window.document.createElement > 'u'
+          ),
+          Sc = !1
+        if (Pe)
+          try {
+            var wl = {}
+            ;(Object.defineProperty(wl, 'passive', {
+              get: function () {
+                Sc = !0
+              },
+            }),
+              window.addEventListener('test', wl, wl),
+              window.removeEventListener('test', wl, wl))
+          } catch {
+            Sc = !1
+          }
+        var Sn = null,
+          Tc = null,
+          Xi = null
+        function Ir() {
+          if (Xi) return Xi
+          var t,
+            e = Tc,
+            n = e.length,
+            a,
+            l = 'value' in Sn ? Sn.value : Sn.textContent,
+            s = l.length
+          for (t = 0; t < n && e[t] === l[t]; t++);
+          var h = n - t
+          for (a = 1; a <= h && e[n - a] === l[s - a]; a++);
+          return (Xi = l.slice(t, 1 < a ? 1 - a : void 0))
+        }
+        function Vi(t) {
+          var e = t.keyCode
+          return (
+            'charCode' in t
+              ? ((t = t.charCode), t === 0 && e === 13 && (t = 13))
+              : (t = e),
+            t === 10 && (t = 13),
+            32 <= t || t === 13 ? t : 0
+          )
+        }
+        function Ii() {
+          return !0
+        }
+        function Zr() {
+          return !1
+        }
+        function oe(t) {
+          function e(n, a, l, s, h) {
+            ;((this._reactName = n),
+              (this._targetInst = l),
+              (this.type = a),
+              (this.nativeEvent = s),
+              (this.target = h),
+              (this.currentTarget = null))
+            for (var g in t)
+              t.hasOwnProperty(g) && ((n = t[g]), (this[g] = n ? n(s) : s[g]))
+            return (
+              (this.isDefaultPrevented = (
+                s.defaultPrevented != null
+                  ? s.defaultPrevented
+                  : s.returnValue === !1
+              )
+                ? Ii
+                : Zr),
+              (this.isPropagationStopped = Zr),
+              this
+            )
+          }
+          return (
+            E(e.prototype, {
+              preventDefault: function () {
+                this.defaultPrevented = !0
+                var n = this.nativeEvent
+                n &&
+                  (n.preventDefault
+                    ? n.preventDefault()
+                    : typeof n.returnValue != 'unknown' && (n.returnValue = !1),
+                  (this.isDefaultPrevented = Ii))
+              },
+              stopPropagation: function () {
+                var n = this.nativeEvent
+                n &&
+                  (n.stopPropagation
+                    ? n.stopPropagation()
+                    : typeof n.cancelBubble != 'unknown' &&
+                      (n.cancelBubble = !0),
+                  (this.isPropagationStopped = Ii))
+              },
+              persist: function () {},
+              isPersistent: Ii,
+            }),
+            e
+          )
+        }
+        var ia = {
+            eventPhase: 0,
+            bubbles: 0,
+            cancelable: 0,
+            timeStamp: function (t) {
+              return t.timeStamp || Date.now()
+            },
+            defaultPrevented: 0,
+            isTrusted: 0,
+          },
+          Zi = oe(ia),
+          Rl = E({}, ia, { view: 0, detail: 0 }),
+          og = oe(Rl),
+          wc,
+          Rc,
+          Ol,
+          qi = E({}, Rl, {
+            screenX: 0,
+            screenY: 0,
+            clientX: 0,
+            clientY: 0,
+            pageX: 0,
+            pageY: 0,
+            ctrlKey: 0,
+            shiftKey: 0,
+            altKey: 0,
+            metaKey: 0,
+            getModifierState: Dc,
+            button: 0,
+            buttons: 0,
+            relatedTarget: function (t) {
+              return t.relatedTarget === void 0
+                ? t.fromElement === t.srcElement
+                  ? t.toElement
+                  : t.fromElement
+                : t.relatedTarget
+            },
+            movementX: function (t) {
+              return 'movementX' in t
+                ? t.movementX
+                : (t !== Ol &&
+                    (Ol && t.type === 'mousemove'
+                      ? ((wc = t.screenX - Ol.screenX),
+                        (Rc = t.screenY - Ol.screenY))
+                      : (Rc = wc = 0),
+                    (Ol = t)),
+                  wc)
+            },
+            movementY: function (t) {
+              return 'movementY' in t ? t.movementY : Rc
+            },
+          }),
+          qr = oe(qi),
+          dg = E({}, qi, { dataTransfer: 0 }),
+          hg = oe(dg),
+          gg = E({}, Rl, { relatedTarget: 0 }),
+          Oc = oe(gg),
+          mg = E({}, ia, {
+            animationName: 0,
+            elapsedTime: 0,
+            pseudoElement: 0,
+          }),
+          Ag = oe(mg),
+          vg = E({}, ia, {
+            clipboardData: function (t) {
+              return 'clipboardData' in t
+                ? t.clipboardData
+                : window.clipboardData
+            },
+          }),
+          yg = oe(vg),
+          Eg = E({}, ia, { data: 0 }),
+          kr = oe(Eg),
+          bg = {
+            Esc: 'Escape',
+            Spacebar: ' ',
+            Left: 'ArrowLeft',
+            Up: 'ArrowUp',
+            Right: 'ArrowRight',
+            Down: 'ArrowDown',
+            Del: 'Delete',
+            Win: 'OS',
+            Menu: 'ContextMenu',
+            Apps: 'ContextMenu',
+            Scroll: 'ScrollLock',
+            MozPrintableKey: 'Unidentified',
+          },
+          pg = {
+            8: 'Backspace',
+            9: 'Tab',
+            12: 'Clear',
+            13: 'Enter',
+            16: 'Shift',
+            17: 'Control',
+            18: 'Alt',
+            19: 'Pause',
+            20: 'CapsLock',
+            27: 'Escape',
+            32: ' ',
+            33: 'PageUp',
+            34: 'PageDown',
+            35: 'End',
+            36: 'Home',
+            37: 'ArrowLeft',
+            38: 'ArrowUp',
+            39: 'ArrowRight',
+            40: 'ArrowDown',
+            45: 'Insert',
+            46: 'Delete',
+            112: 'F1',
+            113: 'F2',
+            114: 'F3',
+            115: 'F4',
+            116: 'F5',
+            117: 'F6',
+            118: 'F7',
+            119: 'F8',
+            120: 'F9',
+            121: 'F10',
+            122: 'F11',
+            123: 'F12',
+            144: 'NumLock',
+            145: 'ScrollLock',
+            224: 'Meta',
+          },
+          xg = {
+            Alt: 'altKey',
+            Control: 'ctrlKey',
+            Meta: 'metaKey',
+            Shift: 'shiftKey',
+          }
+        function Sg(t) {
+          var e = this.nativeEvent
+          return e.getModifierState
+            ? e.getModifierState(t)
+            : (t = xg[t])
+              ? !!e[t]
+              : !1
+        }
+        function Dc() {
+          return Sg
+        }
+        var Tg = E({}, Rl, {
+            key: function (t) {
+              if (t.key) {
+                var e = bg[t.key] || t.key
+                if (e !== 'Unidentified') return e
+              }
+              return t.type === 'keypress'
+                ? ((t = Vi(t)), t === 13 ? 'Enter' : String.fromCharCode(t))
+                : t.type === 'keydown' || t.type === 'keyup'
+                  ? pg[t.keyCode] || 'Unidentified'
+                  : ''
+            },
+            code: 0,
+            location: 0,
+            ctrlKey: 0,
+            shiftKey: 0,
+            altKey: 0,
+            metaKey: 0,
+            repeat: 0,
+            locale: 0,
+            getModifierState: Dc,
+            charCode: function (t) {
+              return t.type === 'keypress' ? Vi(t) : 0
+            },
+            keyCode: function (t) {
+              return t.type === 'keydown' || t.type === 'keyup' ? t.keyCode : 0
+            },
+            which: function (t) {
+              return t.type === 'keypress'
+                ? Vi(t)
+                : t.type === 'keydown' || t.type === 'keyup'
+                  ? t.keyCode
+                  : 0
+            },
+          }),
+          wg = oe(Tg),
+          Rg = E({}, qi, {
+            pointerId: 0,
+            width: 0,
+            height: 0,
+            pressure: 0,
+            tangentialPressure: 0,
+            tiltX: 0,
+            tiltY: 0,
+            twist: 0,
+            pointerType: 0,
+            isPrimary: 0,
+          }),
+          Kr = oe(Rg),
+          Og = E({}, Rl, {
+            touches: 0,
+            targetTouches: 0,
+            changedTouches: 0,
+            altKey: 0,
+            metaKey: 0,
+            ctrlKey: 0,
+            shiftKey: 0,
+            getModifierState: Dc,
+          }),
+          Dg = oe(Og),
+          Cg = E({}, ia, { propertyName: 0, elapsedTime: 0, pseudoElement: 0 }),
+          Mg = oe(Cg),
+          jg = E({}, qi, {
+            deltaX: function (t) {
+              return 'deltaX' in t
+                ? t.deltaX
+                : 'wheelDeltaX' in t
+                  ? -t.wheelDeltaX
+                  : 0
+            },
+            deltaY: function (t) {
+              return 'deltaY' in t
+                ? t.deltaY
+                : 'wheelDeltaY' in t
+                  ? -t.wheelDeltaY
+                  : 'wheelDelta' in t
+                    ? -t.wheelDelta
+                    : 0
+            },
+            deltaZ: 0,
+            deltaMode: 0,
+          }),
+          Hg = oe(jg),
+          Ng = E({}, ia, { newState: 0, oldState: 0 }),
+          Bg = oe(Ng),
+          Ug = [9, 13, 27, 32],
+          Cc = Pe && 'CompositionEvent' in window,
+          Dl = null
+        Pe && 'documentMode' in document && (Dl = document.documentMode)
+        var Qg = Pe && 'TextEvent' in window && !Dl,
+          Wr = Pe && (!Cc || (Dl && 8 < Dl && 11 >= Dl)),
+          Fr = ' ',
+          Jr = !1
+        function Pr(t, e) {
+          switch (t) {
+            case 'keyup':
+              return Ug.indexOf(e.keyCode) !== -1
+            case 'keydown':
+              return e.keyCode !== 229
+            case 'keypress':
+            case 'mousedown':
+            case 'focusout':
+              return !0
+            default:
+              return !1
+          }
+        }
+        function _r(t) {
+          return (
+            (t = t.detail),
+            typeof t == 'object' && 'data' in t ? t.data : null
+          )
+        }
+        var La = !1
+        function Yg(t, e) {
+          switch (t) {
+            case 'compositionend':
+              return _r(e)
+            case 'keypress':
+              return e.which !== 32 ? null : ((Jr = !0), Fr)
+            case 'textInput':
+              return ((t = e.data), t === Fr && Jr ? null : t)
+            default:
+              return null
+          }
+        }
+        function Lg(t, e) {
+          if (La)
+            return t === 'compositionend' || (!Cc && Pr(t, e))
+              ? ((t = Ir()), (Xi = Tc = Sn = null), (La = !1), t)
+              : null
+          switch (t) {
+            case 'paste':
+              return null
+            case 'keypress':
+              if (
+                !(e.ctrlKey || e.altKey || e.metaKey) ||
+                (e.ctrlKey && e.altKey)
+              ) {
+                if (e.char && 1 < e.char.length) return e.char
+                if (e.which) return String.fromCharCode(e.which)
+              }
+              return null
+            case 'compositionend':
+              return Wr && e.locale !== 'ko' ? null : e.data
+            default:
+              return null
+          }
+        }
+        var zg = {
+          color: !0,
+          date: !0,
+          datetime: !0,
+          'datetime-local': !0,
+          email: !0,
+          month: !0,
+          number: !0,
+          password: !0,
+          range: !0,
+          search: !0,
+          tel: !0,
+          text: !0,
+          time: !0,
+          url: !0,
+          week: !0,
+        }
+        function $r(t) {
+          var e = t && t.nodeName && t.nodeName.toLowerCase()
+          return e === 'input' ? !!zg[t.type] : e === 'textarea'
+        }
+        function to(t, e, n, a) {
+          ;(Qa ? (Ya ? Ya.push(a) : (Ya = [a])) : (Qa = a),
+            (e = ju(e, 'onChange')),
+            0 < e.length &&
+              ((n = new Zi('onChange', 'change', null, n, a)),
+              t.push({ event: n, listeners: e })))
+        }
+        var Cl = null,
+          Ml = null
+        function Gg(t) {
+          Ud(t, 0)
+        }
+        function ki(t) {
+          var e = Sl(t)
+          if (Ur(e)) return t
+        }
+        function eo(t, e) {
+          if (t === 'change') return e
+        }
+        var no = !1
+        if (Pe) {
+          var Mc
+          if (Pe) {
+            var jc = 'oninput' in document
+            if (!jc) {
+              var ao = document.createElement('div')
+              ;(ao.setAttribute('oninput', 'return;'),
+                (jc = typeof ao.oninput == 'function'))
+            }
+            Mc = jc
+          } else Mc = !1
+          no = Mc && (!document.documentMode || 9 < document.documentMode)
+        }
+        function lo() {
+          Cl && (Cl.detachEvent('onpropertychange', io), (Ml = Cl = null))
+        }
+        function io(t) {
+          if (t.propertyName === 'value' && ki(Ml)) {
+            var e = []
+            ;(to(e, Ml, t, pc(t)), Vr(Gg, e))
+          }
+        }
+        function Xg(t, e, n) {
+          t === 'focusin'
+            ? (lo(), (Cl = e), (Ml = n), Cl.attachEvent('onpropertychange', io))
+            : t === 'focusout' && lo()
+        }
+        function Vg(t) {
+          if (t === 'selectionchange' || t === 'keyup' || t === 'keydown')
+            return ki(Ml)
+        }
+        function Ig(t, e) {
+          if (t === 'click') return ki(e)
+        }
+        function Zg(t, e) {
+          if (t === 'input' || t === 'change') return ki(e)
+        }
+        function qg(t, e) {
+          return (
+            (t === e && (t !== 0 || 1 / t === 1 / e)) || (t !== t && e !== e)
+          )
+        }
+        var ye = typeof Object.is == 'function' ? Object.is : qg
+        function jl(t, e) {
+          if (ye(t, e)) return !0
+          if (
+            typeof t != 'object' ||
+            t === null ||
+            typeof e != 'object' ||
+            e === null
+          )
+            return !1
+          var n = Object.keys(t),
+            a = Object.keys(e)
+          if (n.length !== a.length) return !1
+          for (a = 0; a < n.length; a++) {
+            var l = n[a]
+            if (!bn.call(e, l) || !ye(t[l], e[l])) return !1
+          }
+          return !0
+        }
+        function uo(t) {
+          for (; t && t.firstChild; ) t = t.firstChild
+          return t
+        }
+        function co(t, e) {
+          var n = uo(t)
+          t = 0
+          for (var a; n; ) {
+            if (n.nodeType === 3) {
+              if (((a = t + n.textContent.length), t <= e && a >= e))
+                return { node: n, offset: e - t }
+              t = a
+            }
+            t: {
+              for (; n; ) {
+                if (n.nextSibling) {
+                  n = n.nextSibling
+                  break t
+                }
+                n = n.parentNode
+              }
+              n = void 0
+            }
+            n = uo(n)
+          }
+        }
+        function so(t, e) {
+          return t && e
+            ? t === e
+              ? !0
+              : t && t.nodeType === 3
+                ? !1
+                : e && e.nodeType === 3
+                  ? so(t, e.parentNode)
+                  : 'contains' in t
+                    ? t.contains(e)
+                    : t.compareDocumentPosition
+                      ? !!(t.compareDocumentPosition(e) & 16)
+                      : !1
+            : !1
+        }
+        function fo(t) {
+          t =
+            t != null &&
+            t.ownerDocument != null &&
+            t.ownerDocument.defaultView != null
+              ? t.ownerDocument.defaultView
+              : window
+          for (var e = zi(t.document); e instanceof t.HTMLIFrameElement; ) {
+            try {
+              var n = typeof e.contentWindow.location.href == 'string'
+            } catch {
+              n = !1
+            }
+            if (n) t = e.contentWindow
+            else break
+            e = zi(t.document)
+          }
+          return e
+        }
+        function Hc(t) {
+          var e = t && t.nodeName && t.nodeName.toLowerCase()
+          return (
+            e &&
+            ((e === 'input' &&
+              (t.type === 'text' ||
+                t.type === 'search' ||
+                t.type === 'tel' ||
+                t.type === 'url' ||
+                t.type === 'password')) ||
+              e === 'textarea' ||
+              t.contentEditable === 'true')
+          )
+        }
+        var kg =
+            Pe && 'documentMode' in document && 11 >= document.documentMode,
+          za = null,
+          Nc = null,
+          Hl = null,
+          Bc = !1
+        function ro(t, e, n) {
+          var a =
+            n.window === n ? n.document : n.nodeType === 9 ? n : n.ownerDocument
+          Bc ||
+            za == null ||
+            za !== zi(a) ||
+            ((a = za),
+            'selectionStart' in a && Hc(a)
+              ? (a = { start: a.selectionStart, end: a.selectionEnd })
+              : ((a = (
+                  (a.ownerDocument && a.ownerDocument.defaultView) ||
+                  window
+                ).getSelection()),
+                (a = {
+                  anchorNode: a.anchorNode,
+                  anchorOffset: a.anchorOffset,
+                  focusNode: a.focusNode,
+                  focusOffset: a.focusOffset,
+                })),
+            (Hl && jl(Hl, a)) ||
+              ((Hl = a),
+              (a = ju(Nc, 'onSelect')),
+              0 < a.length &&
+                ((e = new Zi('onSelect', 'select', null, e, n)),
+                t.push({ event: e, listeners: a }),
+                (e.target = za))))
+        }
+        function ua(t, e) {
+          var n = {}
+          return (
+            (n[t.toLowerCase()] = e.toLowerCase()),
+            (n['Webkit' + t] = 'webkit' + e),
+            (n['Moz' + t] = 'moz' + e),
+            n
+          )
+        }
+        var Ga = {
+            animationend: ua('Animation', 'AnimationEnd'),
+            animationiteration: ua('Animation', 'AnimationIteration'),
+            animationstart: ua('Animation', 'AnimationStart'),
+            transitionrun: ua('Transition', 'TransitionRun'),
+            transitionstart: ua('Transition', 'TransitionStart'),
+            transitioncancel: ua('Transition', 'TransitionCancel'),
+            transitionend: ua('Transition', 'TransitionEnd'),
+          },
+          Uc = {},
+          oo = {}
+        Pe &&
+          ((oo = document.createElement('div').style),
+          'AnimationEvent' in window ||
+            (delete Ga.animationend.animation,
+            delete Ga.animationiteration.animation,
+            delete Ga.animationstart.animation),
+          'TransitionEvent' in window || delete Ga.transitionend.transition)
+        function ca(t) {
+          if (Uc[t]) return Uc[t]
+          if (!Ga[t]) return t
+          var e = Ga[t],
+            n
+          for (n in e) if (e.hasOwnProperty(n) && n in oo) return (Uc[t] = e[n])
+          return t
+        }
+        var ho = ca('animationend'),
+          go = ca('animationiteration'),
+          mo = ca('animationstart'),
+          Kg = ca('transitionrun'),
+          Wg = ca('transitionstart'),
+          Fg = ca('transitioncancel'),
+          Ao = ca('transitionend'),
+          vo = new Map(),
+          Qc =
+            'abort auxClick beforeToggle cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel'.split(
+              ' ',
+            )
+        Qc.push('scrollEnd')
+        function ze(t, e) {
+          ;(vo.set(t, e), la(e, [t]))
+        }
+        var yo = new WeakMap()
+        function De(t, e) {
+          if (typeof t == 'object' && t !== null) {
+            var n = yo.get(t)
+            return n !== void 0
+              ? n
+              : ((e = { value: t, source: e, stack: Nr(e) }), yo.set(t, e), e)
+          }
+          return { value: t, source: e, stack: Nr(e) }
+        }
+        var Ce = [],
+          Xa = 0,
+          Yc = 0
+        function Ki() {
+          for (var t = Xa, e = (Yc = Xa = 0); e < t; ) {
+            var n = Ce[e]
+            Ce[e++] = null
+            var a = Ce[e]
+            Ce[e++] = null
+            var l = Ce[e]
+            Ce[e++] = null
+            var s = Ce[e]
+            if (((Ce[e++] = null), a !== null && l !== null)) {
+              var h = a.pending
+              ;(h === null ? (l.next = l) : ((l.next = h.next), (h.next = l)),
+                (a.pending = l))
+            }
+            s !== 0 && Eo(n, l, s)
+          }
+        }
+        function Wi(t, e, n, a) {
+          ;((Ce[Xa++] = t),
+            (Ce[Xa++] = e),
+            (Ce[Xa++] = n),
+            (Ce[Xa++] = a),
+            (Yc |= a),
+            (t.lanes |= a),
+            (t = t.alternate),
+            t !== null && (t.lanes |= a))
+        }
+        function Lc(t, e, n, a) {
+          return (Wi(t, e, n, a), Fi(t))
+        }
+        function Va(t, e) {
+          return (Wi(t, null, null, e), Fi(t))
+        }
+        function Eo(t, e, n) {
+          t.lanes |= n
+          var a = t.alternate
+          a !== null && (a.lanes |= n)
+          for (var l = !1, s = t.return; s !== null; )
+            ((s.childLanes |= n),
+              (a = s.alternate),
+              a !== null && (a.childLanes |= n),
+              s.tag === 22 &&
+                ((t = s.stateNode),
+                t === null || t._visibility & 1 || (l = !0)),
+              (t = s),
+              (s = s.return))
+          return t.tag === 3
+            ? ((s = t.stateNode),
+              l &&
+                e !== null &&
+                ((l = 31 - ve(n)),
+                (t = s.hiddenUpdates),
+                (a = t[l]),
+                a === null ? (t[l] = [e]) : a.push(e),
+                (e.lane = n | 536870912)),
+              s)
+            : null
+        }
+        function Fi(t) {
+          if (50 < ai) throw ((ai = 0), (Zs = null), Error(f(185)))
+          for (var e = t.return; e !== null; ) ((t = e), (e = t.return))
+          return t.tag === 3 ? t.stateNode : null
+        }
+        var Ia = {}
+        function Jg(t, e, n, a) {
+          ;((this.tag = t),
+            (this.key = n),
+            (this.sibling =
+              this.child =
+              this.return =
+              this.stateNode =
+              this.type =
+              this.elementType =
+                null),
+            (this.index = 0),
+            (this.refCleanup = this.ref = null),
+            (this.pendingProps = e),
+            (this.dependencies =
+              this.memoizedState =
+              this.updateQueue =
+              this.memoizedProps =
+                null),
+            (this.mode = a),
+            (this.subtreeFlags = this.flags = 0),
+            (this.deletions = null),
+            (this.childLanes = this.lanes = 0),
+            (this.alternate = null))
+        }
+        function Ee(t, e, n, a) {
+          return new Jg(t, e, n, a)
+        }
+        function zc(t) {
+          return ((t = t.prototype), !(!t || !t.isReactComponent))
+        }
+        function _e(t, e) {
+          var n = t.alternate
+          return (
+            n === null
+              ? ((n = Ee(t.tag, e, t.key, t.mode)),
+                (n.elementType = t.elementType),
+                (n.type = t.type),
+                (n.stateNode = t.stateNode),
+                (n.alternate = t),
+                (t.alternate = n))
+              : ((n.pendingProps = e),
+                (n.type = t.type),
+                (n.flags = 0),
+                (n.subtreeFlags = 0),
+                (n.deletions = null)),
+            (n.flags = t.flags & 65011712),
+            (n.childLanes = t.childLanes),
+            (n.lanes = t.lanes),
+            (n.child = t.child),
+            (n.memoizedProps = t.memoizedProps),
+            (n.memoizedState = t.memoizedState),
+            (n.updateQueue = t.updateQueue),
+            (e = t.dependencies),
+            (n.dependencies =
+              e === null
+                ? null
+                : { lanes: e.lanes, firstContext: e.firstContext }),
+            (n.sibling = t.sibling),
+            (n.index = t.index),
+            (n.ref = t.ref),
+            (n.refCleanup = t.refCleanup),
+            n
+          )
+        }
+        function bo(t, e) {
+          t.flags &= 65011714
+          var n = t.alternate
+          return (
+            n === null
+              ? ((t.childLanes = 0),
+                (t.lanes = e),
+                (t.child = null),
+                (t.subtreeFlags = 0),
+                (t.memoizedProps = null),
+                (t.memoizedState = null),
+                (t.updateQueue = null),
+                (t.dependencies = null),
+                (t.stateNode = null))
+              : ((t.childLanes = n.childLanes),
+                (t.lanes = n.lanes),
+                (t.child = n.child),
+                (t.subtreeFlags = 0),
+                (t.deletions = null),
+                (t.memoizedProps = n.memoizedProps),
+                (t.memoizedState = n.memoizedState),
+                (t.updateQueue = n.updateQueue),
+                (t.type = n.type),
+                (e = n.dependencies),
+                (t.dependencies =
+                  e === null
+                    ? null
+                    : { lanes: e.lanes, firstContext: e.firstContext })),
+            t
+          )
+        }
+        function Ji(t, e, n, a, l, s) {
+          var h = 0
+          if (((a = t), typeof t == 'function')) zc(t) && (h = 1)
+          else if (typeof t == 'string')
+            h = _m(t, n, it.current)
+              ? 26
+              : t === 'html' || t === 'head' || t === 'body'
+                ? 27
+                : 5
+          else
+            t: switch (t) {
+              case W:
+                return (
+                  (t = Ee(31, n, e, l)),
+                  (t.elementType = W),
+                  (t.lanes = s),
+                  t
+                )
+              case N:
+                return sa(n.children, l, s, e)
+              case x:
+                ;((h = 8), (l |= 24))
+                break
+              case p:
+                return (
+                  (t = Ee(12, n, e, l | 2)),
+                  (t.elementType = p),
+                  (t.lanes = s),
+                  t
+                )
+              case V:
+                return (
+                  (t = Ee(13, n, e, l)),
+                  (t.elementType = V),
+                  (t.lanes = s),
+                  t
+                )
+              case j:
+                return (
+                  (t = Ee(19, n, e, l)),
+                  (t.elementType = j),
+                  (t.lanes = s),
+                  t
+                )
+              default:
+                if (typeof t == 'object' && t !== null)
+                  switch (t.$$typeof) {
+                    case T:
+                    case U:
+                      h = 10
+                      break t
+                    case D:
+                      h = 9
+                      break t
+                    case I:
+                      h = 11
+                      break t
+                    case G:
+                      h = 14
+                      break t
+                    case L:
+                      ;((h = 16), (a = null))
+                      break t
+                  }
+                ;((h = 29),
+                  (n = Error(f(130, t === null ? 'null' : typeof t, ''))),
+                  (a = null))
+            }
+          return (
+            (e = Ee(h, n, e, l)),
+            (e.elementType = t),
+            (e.type = a),
+            (e.lanes = s),
+            e
+          )
+        }
+        function sa(t, e, n, a) {
+          return ((t = Ee(7, t, a, e)), (t.lanes = n), t)
+        }
+        function Gc(t, e, n) {
+          return ((t = Ee(6, t, null, e)), (t.lanes = n), t)
+        }
+        function Xc(t, e, n) {
+          return (
+            (e = Ee(4, t.children !== null ? t.children : [], t.key, e)),
+            (e.lanes = n),
+            (e.stateNode = {
+              containerInfo: t.containerInfo,
+              pendingChildren: null,
+              implementation: t.implementation,
+            }),
+            e
+          )
+        }
+        var Za = [],
+          qa = 0,
+          Pi = null,
+          _i = 0,
+          Me = [],
+          je = 0,
+          fa = null,
+          $e = 1,
+          tn = ''
+        function ra(t, e) {
+          ;((Za[qa++] = _i), (Za[qa++] = Pi), (Pi = t), (_i = e))
+        }
+        function po(t, e, n) {
+          ;((Me[je++] = $e), (Me[je++] = tn), (Me[je++] = fa), (fa = t))
+          var a = $e
+          t = tn
+          var l = 32 - ve(a) - 1
+          ;((a &= ~(1 << l)), (n += 1))
+          var s = 32 - ve(e) + l
+          if (30 < s) {
+            var h = l - (l % 5)
+            ;((s = (a & ((1 << h) - 1)).toString(32)),
+              (a >>= h),
+              (l -= h),
+              ($e = (1 << (32 - ve(e) + l)) | (n << l) | a),
+              (tn = s + t))
+          } else (($e = (1 << s) | (n << l) | a), (tn = t))
+        }
+        function Vc(t) {
+          t.return !== null && (ra(t, 1), po(t, 1, 0))
+        }
+        function Ic(t) {
+          for (; t === Pi; )
+            ((Pi = Za[--qa]), (Za[qa] = null), (_i = Za[--qa]), (Za[qa] = null))
+          for (; t === fa; )
+            ((fa = Me[--je]),
+              (Me[je] = null),
+              (tn = Me[--je]),
+              (Me[je] = null),
+              ($e = Me[--je]),
+              (Me[je] = null))
+        }
+        var se = null,
+          Yt = null,
+          xt = !1,
+          oa = null,
+          Ve = !1,
+          Zc = Error(f(519))
+        function da(t) {
+          var e = Error(f(418, ''))
+          throw (Ul(De(e, t)), Zc)
+        }
+        function xo(t) {
+          var e = t.stateNode,
+            n = t.type,
+            a = t.memoizedProps
+          switch (((e[ne] = t), (e[re] = a), n)) {
+            case 'dialog':
+              ;(yt('cancel', e), yt('close', e))
+              break
+            case 'iframe':
+            case 'object':
+            case 'embed':
+              yt('load', e)
+              break
+            case 'video':
+            case 'audio':
+              for (n = 0; n < ii.length; n++) yt(ii[n], e)
+              break
+            case 'source':
+              yt('error', e)
+              break
+            case 'img':
+            case 'image':
+            case 'link':
+              ;(yt('error', e), yt('load', e))
+              break
+            case 'details':
+              yt('toggle', e)
+              break
+            case 'input':
+              ;(yt('invalid', e),
+                Qr(
+                  e,
+                  a.value,
+                  a.defaultValue,
+                  a.checked,
+                  a.defaultChecked,
+                  a.type,
+                  a.name,
+                  !0,
+                ),
+                Li(e))
+              break
+            case 'select':
+              yt('invalid', e)
+              break
+            case 'textarea':
+              ;(yt('invalid', e),
+                Lr(e, a.value, a.defaultValue, a.children),
+                Li(e))
+          }
+          ;((n = a.children),
+            (typeof n != 'string' &&
+              typeof n != 'number' &&
+              typeof n != 'bigint') ||
+            e.textContent === '' + n ||
+            a.suppressHydrationWarning === !0 ||
+            zd(e.textContent, n)
+              ? (a.popover != null && (yt('beforetoggle', e), yt('toggle', e)),
+                a.onScroll != null && yt('scroll', e),
+                a.onScrollEnd != null && yt('scrollend', e),
+                a.onClick != null && (e.onclick = Hu),
+                (e = !0))
+              : (e = !1),
+            e || da(t))
+        }
+        function So(t) {
+          for (se = t.return; se; )
+            switch (se.tag) {
+              case 5:
+              case 13:
+                Ve = !1
+                return
+              case 27:
+              case 3:
+                Ve = !0
+                return
+              default:
+                se = se.return
+            }
+        }
+        function Nl(t) {
+          if (t !== se) return !1
+          if (!xt) return (So(t), (xt = !0), !1)
+          var e = t.tag,
+            n
+          if (
+            ((n = e !== 3 && e !== 27) &&
+              ((n = e === 5) &&
+                ((n = t.type),
+                (n =
+                  !(n !== 'form' && n !== 'button') ||
+                  cf(t.type, t.memoizedProps))),
+              (n = !n)),
+            n && Yt && da(t),
+            So(t),
+            e === 13)
+          ) {
+            if (
+              ((t = t.memoizedState),
+              (t = t !== null ? t.dehydrated : null),
+              !t)
+            )
+              throw Error(f(317))
+            t: {
+              for (t = t.nextSibling, e = 0; t; ) {
+                if (t.nodeType === 8)
+                  if (((n = t.data), n === '/$')) {
+                    if (e === 0) {
+                      Yt = Xe(t.nextSibling)
+                      break t
+                    }
+                    e--
+                  } else (n !== '$' && n !== '$!' && n !== '$?') || e++
+                t = t.nextSibling
+              }
+              Yt = null
+            }
+          } else
+            e === 27
+              ? ((e = Yt),
+                zn(t.type) ? ((t = of), (of = null), (Yt = t)) : (Yt = e))
+              : (Yt = se ? Xe(t.stateNode.nextSibling) : null)
+          return !0
+        }
+        function Bl() {
+          ;((Yt = se = null), (xt = !1))
+        }
+        function To() {
+          var t = oa
+          return (
+            t !== null &&
+              (ge === null ? (ge = t) : ge.push.apply(ge, t), (oa = null)),
+            t
+          )
+        }
+        function Ul(t) {
+          oa === null ? (oa = [t]) : oa.push(t)
+        }
+        var qc = q(null),
+          ha = null,
+          en = null
+        function Tn(t, e, n) {
+          ;(J(qc, e._currentValue), (e._currentValue = n))
+        }
+        function nn(t) {
+          ;((t._currentValue = qc.current), P(qc))
+        }
+        function kc(t, e, n) {
+          for (; t !== null; ) {
+            var a = t.alternate
+            if (
+              ((t.childLanes & e) !== e
+                ? ((t.childLanes |= e), a !== null && (a.childLanes |= e))
+                : a !== null && (a.childLanes & e) !== e && (a.childLanes |= e),
+              t === n)
+            )
+              break
+            t = t.return
+          }
+        }
+        function Kc(t, e, n, a) {
+          var l = t.child
+          for (l !== null && (l.return = t); l !== null; ) {
+            var s = l.dependencies
+            if (s !== null) {
+              var h = l.child
+              s = s.firstContext
+              t: for (; s !== null; ) {
+                var g = s
+                s = l
+                for (var S = 0; S < e.length; S++)
+                  if (g.context === e[S]) {
+                    ;((s.lanes |= n),
+                      (g = s.alternate),
+                      g !== null && (g.lanes |= n),
+                      kc(s.return, n, t),
+                      a || (h = null))
+                    break t
+                  }
+                s = g.next
+              }
+            } else if (l.tag === 18) {
+              if (((h = l.return), h === null)) throw Error(f(341))
+              ;((h.lanes |= n),
+                (s = h.alternate),
+                s !== null && (s.lanes |= n),
+                kc(h, n, t),
+                (h = null))
+            } else h = l.child
+            if (h !== null) h.return = l
+            else
+              for (h = l; h !== null; ) {
+                if (h === t) {
+                  h = null
+                  break
+                }
+                if (((l = h.sibling), l !== null)) {
+                  ;((l.return = h.return), (h = l))
+                  break
+                }
+                h = h.return
+              }
+            l = h
+          }
+        }
+        function Ql(t, e, n, a) {
+          t = null
+          for (var l = e, s = !1; l !== null; ) {
+            if (!s) {
+              if ((l.flags & 524288) !== 0) s = !0
+              else if ((l.flags & 262144) !== 0) break
+            }
+            if (l.tag === 10) {
+              var h = l.alternate
+              if (h === null) throw Error(f(387))
+              if (((h = h.memoizedProps), h !== null)) {
+                var g = l.type
+                ye(l.pendingProps.value, h.value) ||
+                  (t !== null ? t.push(g) : (t = [g]))
+              }
+            } else if (l === Nt.current) {
+              if (((h = l.alternate), h === null)) throw Error(f(387))
+              h.memoizedState.memoizedState !== l.memoizedState.memoizedState &&
+                (t !== null ? t.push(oi) : (t = [oi]))
+            }
+            l = l.return
+          }
+          ;(t !== null && Kc(e, t, n, a), (e.flags |= 262144))
+        }
+        function $i(t) {
+          for (t = t.firstContext; t !== null; ) {
+            if (!ye(t.context._currentValue, t.memoizedValue)) return !0
+            t = t.next
+          }
+          return !1
+        }
+        function ga(t) {
+          ;((ha = t),
+            (en = null),
+            (t = t.dependencies),
+            t !== null && (t.firstContext = null))
+        }
+        function ae(t) {
+          return wo(ha, t)
+        }
+        function tu(t, e) {
+          return (ha === null && ga(t), wo(t, e))
+        }
+        function wo(t, e) {
+          var n = e._currentValue
+          if (
+            ((e = { context: e, memoizedValue: n, next: null }), en === null)
+          ) {
+            if (t === null) throw Error(f(308))
+            ;((en = e),
+              (t.dependencies = { lanes: 0, firstContext: e }),
+              (t.flags |= 524288))
+          } else en = en.next = e
+          return n
+        }
+        var Pg =
+            typeof AbortController < 'u'
+              ? AbortController
+              : function () {
+                  var t = [],
+                    e = (this.signal = {
+                      aborted: !1,
+                      addEventListener: function (n, a) {
+                        t.push(a)
+                      },
+                    })
+                  this.abort = function () {
+                    ;((e.aborted = !0),
+                      t.forEach(function (n) {
+                        return n()
+                      }))
+                  }
+                },
+          _g = u.unstable_scheduleCallback,
+          $g = u.unstable_NormalPriority,
+          It = {
+            $$typeof: U,
+            Consumer: null,
+            Provider: null,
+            _currentValue: null,
+            _currentValue2: null,
+            _threadCount: 0,
+          }
+        function Wc() {
+          return { controller: new Pg(), data: new Map(), refCount: 0 }
+        }
+        function Yl(t) {
+          ;(t.refCount--,
+            t.refCount === 0 &&
+              _g($g, function () {
+                t.controller.abort()
+              }))
+        }
+        var Ll = null,
+          Fc = 0,
+          ka = 0,
+          Ka = null
+        function tm(t, e) {
+          if (Ll === null) {
+            var n = (Ll = [])
+            ;((Fc = 0),
+              (ka = Ps()),
+              (Ka = {
+                status: 'pending',
+                value: void 0,
+                then: function (a) {
+                  n.push(a)
+                },
+              }))
+          }
+          return (Fc++, e.then(Ro, Ro), e)
+        }
+        function Ro() {
+          if (--Fc === 0 && Ll !== null) {
+            Ka !== null && (Ka.status = 'fulfilled')
+            var t = Ll
+            ;((Ll = null), (ka = 0), (Ka = null))
+            for (var e = 0; e < t.length; e++) (0, t[e])()
+          }
+        }
+        function em(t, e) {
+          var n = [],
+            a = {
+              status: 'pending',
+              value: null,
+              reason: null,
+              then: function (l) {
+                n.push(l)
+              },
+            }
+          return (
+            t.then(
+              function () {
+                ;((a.status = 'fulfilled'), (a.value = e))
+                for (var l = 0; l < n.length; l++) (0, n[l])(e)
+              },
+              function (l) {
+                for (
+                  a.status = 'rejected', a.reason = l, l = 0;
+                  l < n.length;
+                  l++
+                )
+                  (0, n[l])(void 0)
+              },
+            ),
+            a
+          )
+        }
+        var Oo = M.S
+        M.S = function (t, e) {
+          ;(typeof e == 'object' &&
+            e !== null &&
+            typeof e.then == 'function' &&
+            tm(t, e),
+            Oo !== null && Oo(t, e))
+        }
+        var ma = q(null)
+        function Jc() {
+          var t = ma.current
+          return t !== null ? t : Mt.pooledCache
+        }
+        function eu(t, e) {
+          e === null ? J(ma, ma.current) : J(ma, e.pool)
+        }
+        function Do() {
+          var t = Jc()
+          return t === null ? null : { parent: It._currentValue, pool: t }
+        }
+        var zl = Error(f(460)),
+          Co = Error(f(474)),
+          nu = Error(f(542)),
+          Pc = { then: function () {} }
+        function Mo(t) {
+          return ((t = t.status), t === 'fulfilled' || t === 'rejected')
+        }
+        function au() {}
+        function jo(t, e, n) {
+          switch (
+            ((n = t[n]),
+            n === void 0 ? t.push(e) : n !== e && (e.then(au, au), (e = n)),
+            e.status)
+          ) {
+            case 'fulfilled':
+              return e.value
+            case 'rejected':
+              throw ((t = e.reason), No(t), t)
+            default:
+              if (typeof e.status == 'string') e.then(au, au)
+              else {
+                if (((t = Mt), t !== null && 100 < t.shellSuspendCounter))
+                  throw Error(f(482))
+                ;((t = e),
+                  (t.status = 'pending'),
+                  t.then(
+                    function (a) {
+                      if (e.status === 'pending') {
+                        var l = e
+                        ;((l.status = 'fulfilled'), (l.value = a))
+                      }
+                    },
+                    function (a) {
+                      if (e.status === 'pending') {
+                        var l = e
+                        ;((l.status = 'rejected'), (l.reason = a))
+                      }
+                    },
+                  ))
+              }
+              switch (e.status) {
+                case 'fulfilled':
+                  return e.value
+                case 'rejected':
+                  throw ((t = e.reason), No(t), t)
+              }
+              throw ((Gl = e), zl)
+          }
+        }
+        var Gl = null
+        function Ho() {
+          if (Gl === null) throw Error(f(459))
+          var t = Gl
+          return ((Gl = null), t)
+        }
+        function No(t) {
+          if (t === zl || t === nu) throw Error(f(483))
+        }
+        var wn = !1
+        function _c(t) {
+          t.updateQueue = {
+            baseState: t.memoizedState,
+            firstBaseUpdate: null,
+            lastBaseUpdate: null,
+            shared: { pending: null, lanes: 0, hiddenCallbacks: null },
+            callbacks: null,
+          }
+        }
+        function $c(t, e) {
+          ;((t = t.updateQueue),
+            e.updateQueue === t &&
+              (e.updateQueue = {
+                baseState: t.baseState,
+                firstBaseUpdate: t.firstBaseUpdate,
+                lastBaseUpdate: t.lastBaseUpdate,
+                shared: t.shared,
+                callbacks: null,
+              }))
+        }
+        function Rn(t) {
+          return { lane: t, tag: 0, payload: null, callback: null, next: null }
+        }
+        function On(t, e, n) {
+          var a = t.updateQueue
+          if (a === null) return null
+          if (((a = a.shared), (St & 2) !== 0)) {
+            var l = a.pending
+            return (
+              l === null ? (e.next = e) : ((e.next = l.next), (l.next = e)),
+              (a.pending = e),
+              (e = Fi(t)),
+              Eo(t, null, n),
+              e
+            )
+          }
+          return (Wi(t, a, e, n), Fi(t))
+        }
+        function Xl(t, e, n) {
+          if (
+            ((e = e.updateQueue),
+            e !== null && ((e = e.shared), (n & 4194048) !== 0))
+          ) {
+            var a = e.lanes
+            ;((a &= t.pendingLanes), (n |= a), (e.lanes = n), wr(t, n))
+          }
+        }
+        function ts(t, e) {
+          var n = t.updateQueue,
+            a = t.alternate
+          if (a !== null && ((a = a.updateQueue), n === a)) {
+            var l = null,
+              s = null
+            if (((n = n.firstBaseUpdate), n !== null)) {
+              do {
+                var h = {
+                  lane: n.lane,
+                  tag: n.tag,
+                  payload: n.payload,
+                  callback: null,
+                  next: null,
+                }
+                ;(s === null ? (l = s = h) : (s = s.next = h), (n = n.next))
+              } while (n !== null)
+              s === null ? (l = s = e) : (s = s.next = e)
+            } else l = s = e
+            ;((n = {
+              baseState: a.baseState,
+              firstBaseUpdate: l,
+              lastBaseUpdate: s,
+              shared: a.shared,
+              callbacks: a.callbacks,
+            }),
+              (t.updateQueue = n))
+            return
+          }
+          ;((t = n.lastBaseUpdate),
+            t === null ? (n.firstBaseUpdate = e) : (t.next = e),
+            (n.lastBaseUpdate = e))
+        }
+        var es = !1
+        function Vl() {
+          if (es) {
+            var t = Ka
+            if (t !== null) throw t
+          }
+        }
+        function Il(t, e, n, a) {
+          es = !1
+          var l = t.updateQueue
+          wn = !1
+          var s = l.firstBaseUpdate,
+            h = l.lastBaseUpdate,
+            g = l.shared.pending
+          if (g !== null) {
+            l.shared.pending = null
+            var S = g,
+              B = S.next
+            ;((S.next = null), h === null ? (s = B) : (h.next = B), (h = S))
+            var X = t.alternate
+            X !== null &&
+              ((X = X.updateQueue),
+              (g = X.lastBaseUpdate),
+              g !== h &&
+                (g === null ? (X.firstBaseUpdate = B) : (g.next = B),
+                (X.lastBaseUpdate = S)))
+          }
+          if (s !== null) {
+            var k = l.baseState
+            ;((h = 0), (X = B = S = null), (g = s))
+            do {
+              var Q = g.lane & -536870913,
+                Y = Q !== g.lane
+              if (Y ? (Et & Q) === Q : (a & Q) === Q) {
+                ;(Q !== 0 && Q === ka && (es = !0),
+                  X !== null &&
+                    (X = X.next =
+                      {
+                        lane: 0,
+                        tag: g.tag,
+                        payload: g.payload,
+                        callback: null,
+                        next: null,
+                      }))
+                t: {
+                  var rt = t,
+                    st = g
+                  Q = e
+                  var Ot = n
+                  switch (st.tag) {
+                    case 1:
+                      if (((rt = st.payload), typeof rt == 'function')) {
+                        k = rt.call(Ot, k, Q)
+                        break t
+                      }
+                      k = rt
+                      break t
+                    case 3:
+                      rt.flags = (rt.flags & -65537) | 128
+                    case 0:
+                      if (
+                        ((rt = st.payload),
+                        (Q = typeof rt == 'function' ? rt.call(Ot, k, Q) : rt),
+                        Q == null)
+                      )
+                        break t
+                      k = E({}, k, Q)
+                      break t
+                    case 2:
+                      wn = !0
+                  }
+                }
+                ;((Q = g.callback),
+                  Q !== null &&
+                    ((t.flags |= 64),
+                    Y && (t.flags |= 8192),
+                    (Y = l.callbacks),
+                    Y === null ? (l.callbacks = [Q]) : Y.push(Q)))
+              } else
+                ((Y = {
+                  lane: Q,
+                  tag: g.tag,
+                  payload: g.payload,
+                  callback: g.callback,
+                  next: null,
+                }),
+                  X === null ? ((B = X = Y), (S = k)) : (X = X.next = Y),
+                  (h |= Q))
+              if (((g = g.next), g === null)) {
+                if (((g = l.shared.pending), g === null)) break
+                ;((Y = g),
+                  (g = Y.next),
+                  (Y.next = null),
+                  (l.lastBaseUpdate = Y),
+                  (l.shared.pending = null))
+              }
+            } while (!0)
+            ;(X === null && (S = k),
+              (l.baseState = S),
+              (l.firstBaseUpdate = B),
+              (l.lastBaseUpdate = X),
+              s === null && (l.shared.lanes = 0),
+              (Un |= h),
+              (t.lanes = h),
+              (t.memoizedState = k))
+          }
+        }
+        function Bo(t, e) {
+          if (typeof t != 'function') throw Error(f(191, t))
+          t.call(e)
+        }
+        function Uo(t, e) {
+          var n = t.callbacks
+          if (n !== null)
+            for (t.callbacks = null, t = 0; t < n.length; t++) Bo(n[t], e)
+        }
+        var Wa = q(null),
+          lu = q(0)
+        function Qo(t, e) {
+          ;((t = rn), J(lu, t), J(Wa, e), (rn = t | e.baseLanes))
+        }
+        function ns() {
+          ;(J(lu, rn), J(Wa, Wa.current))
+        }
+        function as() {
+          ;((rn = lu.current), P(Wa), P(lu))
+        }
+        var Dn = 0,
+          gt = null,
+          wt = null,
+          Xt = null,
+          iu = !1,
+          Fa = !1,
+          Aa = !1,
+          uu = 0,
+          Zl = 0,
+          Ja = null,
+          nm = 0
+        function zt() {
+          throw Error(f(321))
+        }
+        function ls(t, e) {
+          if (e === null) return !1
+          for (var n = 0; n < e.length && n < t.length; n++)
+            if (!ye(t[n], e[n])) return !1
+          return !0
+        }
+        function is(t, e, n, a, l, s) {
+          return (
+            (Dn = s),
+            (gt = e),
+            (e.memoizedState = null),
+            (e.updateQueue = null),
+            (e.lanes = 0),
+            (M.H = t === null || t.memoizedState === null ? E0 : b0),
+            (Aa = !1),
+            (s = n(a, l)),
+            (Aa = !1),
+            Fa && (s = Lo(e, n, a, l)),
+            Yo(t),
+            s
+          )
+        }
+        function Yo(t) {
+          M.H = du
+          var e = wt !== null && wt.next !== null
+          if (
+            ((Dn = 0),
+            (Xt = wt = gt = null),
+            (iu = !1),
+            (Zl = 0),
+            (Ja = null),
+            e)
+          )
+            throw Error(f(300))
+          t === null ||
+            Kt ||
+            ((t = t.dependencies), t !== null && $i(t) && (Kt = !0))
+        }
+        function Lo(t, e, n, a) {
+          gt = t
+          var l = 0
+          do {
+            if ((Fa && (Ja = null), (Zl = 0), (Fa = !1), 25 <= l))
+              throw Error(f(301))
+            if (((l += 1), (Xt = wt = null), t.updateQueue != null)) {
+              var s = t.updateQueue
+              ;((s.lastEffect = null),
+                (s.events = null),
+                (s.stores = null),
+                s.memoCache != null && (s.memoCache.index = 0))
+            }
+            ;((M.H = fm), (s = e(n, a)))
+          } while (Fa)
+          return s
+        }
+        function am() {
+          var t = M.H,
+            e = t.useState()[0]
+          return (
+            (e = typeof e.then == 'function' ? ql(e) : e),
+            (t = t.useState()[0]),
+            (wt !== null ? wt.memoizedState : null) !== t && (gt.flags |= 1024),
+            e
+          )
+        }
+        function us() {
+          var t = uu !== 0
+          return ((uu = 0), t)
+        }
+        function cs(t, e, n) {
+          ;((e.updateQueue = t.updateQueue),
+            (e.flags &= -2053),
+            (t.lanes &= ~n))
+        }
+        function ss(t) {
+          if (iu) {
+            for (t = t.memoizedState; t !== null; ) {
+              var e = t.queue
+              ;(e !== null && (e.pending = null), (t = t.next))
+            }
+            iu = !1
+          }
+          ;((Dn = 0),
+            (Xt = wt = gt = null),
+            (Fa = !1),
+            (Zl = uu = 0),
+            (Ja = null))
+        }
+        function de() {
+          var t = {
+            memoizedState: null,
+            baseState: null,
+            baseQueue: null,
+            queue: null,
+            next: null,
+          }
+          return (
+            Xt === null ? (gt.memoizedState = Xt = t) : (Xt = Xt.next = t),
+            Xt
+          )
+        }
+        function Vt() {
+          if (wt === null) {
+            var t = gt.alternate
+            t = t !== null ? t.memoizedState : null
+          } else t = wt.next
+          var e = Xt === null ? gt.memoizedState : Xt.next
+          if (e !== null) ((Xt = e), (wt = t))
+          else {
+            if (t === null)
+              throw gt.alternate === null ? Error(f(467)) : Error(f(310))
+            ;((wt = t),
+              (t = {
+                memoizedState: wt.memoizedState,
+                baseState: wt.baseState,
+                baseQueue: wt.baseQueue,
+                queue: wt.queue,
+                next: null,
+              }),
+              Xt === null ? (gt.memoizedState = Xt = t) : (Xt = Xt.next = t))
+          }
+          return Xt
+        }
+        function fs() {
+          return {
+            lastEffect: null,
+            events: null,
+            stores: null,
+            memoCache: null,
+          }
+        }
+        function ql(t) {
+          var e = Zl
+          return (
+            (Zl += 1),
+            Ja === null && (Ja = []),
+            (t = jo(Ja, t, e)),
+            (e = gt),
+            (Xt === null ? e.memoizedState : Xt.next) === null &&
+              ((e = e.alternate),
+              (M.H = e === null || e.memoizedState === null ? E0 : b0)),
+            t
+          )
+        }
+        function cu(t) {
+          if (t !== null && typeof t == 'object') {
+            if (typeof t.then == 'function') return ql(t)
+            if (t.$$typeof === U) return ae(t)
+          }
+          throw Error(f(438, String(t)))
+        }
+        function rs(t) {
+          var e = null,
+            n = gt.updateQueue
+          if ((n !== null && (e = n.memoCache), e == null)) {
+            var a = gt.alternate
+            a !== null &&
+              ((a = a.updateQueue),
+              a !== null &&
+                ((a = a.memoCache),
+                a != null &&
+                  (e = {
+                    data: a.data.map(function (l) {
+                      return l.slice()
+                    }),
+                    index: 0,
+                  })))
+          }
+          if (
+            (e == null && (e = { data: [], index: 0 }),
+            n === null && ((n = fs()), (gt.updateQueue = n)),
+            (n.memoCache = e),
+            (n = e.data[e.index]),
+            n === void 0)
+          )
+            for (n = e.data[e.index] = Array(t), a = 0; a < t; a++) n[a] = F
+          return (e.index++, n)
+        }
+        function an(t, e) {
+          return typeof e == 'function' ? e(t) : e
+        }
+        function su(t) {
+          var e = Vt()
+          return os(e, wt, t)
+        }
+        function os(t, e, n) {
+          var a = t.queue
+          if (a === null) throw Error(f(311))
+          a.lastRenderedReducer = n
+          var l = t.baseQueue,
+            s = a.pending
+          if (s !== null) {
+            if (l !== null) {
+              var h = l.next
+              ;((l.next = s.next), (s.next = h))
+            }
+            ;((e.baseQueue = l = s), (a.pending = null))
+          }
+          if (((s = t.baseState), l === null)) t.memoizedState = s
+          else {
+            e = l.next
+            var g = (h = null),
+              S = null,
+              B = e,
+              X = !1
+            do {
+              var k = B.lane & -536870913
+              if (k !== B.lane ? (Et & k) === k : (Dn & k) === k) {
+                var Q = B.revertLane
+                if (Q === 0)
+                  (S !== null &&
+                    (S = S.next =
+                      {
+                        lane: 0,
+                        revertLane: 0,
+                        action: B.action,
+                        hasEagerState: B.hasEagerState,
+                        eagerState: B.eagerState,
+                        next: null,
+                      }),
+                    k === ka && (X = !0))
+                else if ((Dn & Q) === Q) {
+                  ;((B = B.next), Q === ka && (X = !0))
+                  continue
+                } else
+                  ((k = {
+                    lane: 0,
+                    revertLane: B.revertLane,
+                    action: B.action,
+                    hasEagerState: B.hasEagerState,
+                    eagerState: B.eagerState,
+                    next: null,
+                  }),
+                    S === null ? ((g = S = k), (h = s)) : (S = S.next = k),
+                    (gt.lanes |= Q),
+                    (Un |= Q))
+                ;((k = B.action),
+                  Aa && n(s, k),
+                  (s = B.hasEagerState ? B.eagerState : n(s, k)))
+              } else
+                ((Q = {
+                  lane: k,
+                  revertLane: B.revertLane,
+                  action: B.action,
+                  hasEagerState: B.hasEagerState,
+                  eagerState: B.eagerState,
+                  next: null,
+                }),
+                  S === null ? ((g = S = Q), (h = s)) : (S = S.next = Q),
+                  (gt.lanes |= k),
+                  (Un |= k))
+              B = B.next
+            } while (B !== null && B !== e)
+            if (
+              (S === null ? (h = s) : (S.next = g),
+              !ye(s, t.memoizedState) &&
+                ((Kt = !0), X && ((n = Ka), n !== null)))
+            )
+              throw n
+            ;((t.memoizedState = s),
+              (t.baseState = h),
+              (t.baseQueue = S),
+              (a.lastRenderedState = s))
+          }
+          return (l === null && (a.lanes = 0), [t.memoizedState, a.dispatch])
+        }
+        function ds(t) {
+          var e = Vt(),
+            n = e.queue
+          if (n === null) throw Error(f(311))
+          n.lastRenderedReducer = t
+          var a = n.dispatch,
+            l = n.pending,
+            s = e.memoizedState
+          if (l !== null) {
+            n.pending = null
+            var h = (l = l.next)
+            do ((s = t(s, h.action)), (h = h.next))
+            while (h !== l)
+            ;(ye(s, e.memoizedState) || (Kt = !0),
+              (e.memoizedState = s),
+              e.baseQueue === null && (e.baseState = s),
+              (n.lastRenderedState = s))
+          }
+          return [s, a]
+        }
+        function zo(t, e, n) {
+          var a = gt,
+            l = Vt(),
+            s = xt
+          if (s) {
+            if (n === void 0) throw Error(f(407))
+            n = n()
+          } else n = e()
+          var h = !ye((wt || l).memoizedState, n)
+          ;(h && ((l.memoizedState = n), (Kt = !0)), (l = l.queue))
+          var g = Vo.bind(null, a, l, t)
+          if (
+            (kl(2048, 8, g, [t]),
+            l.getSnapshot !== e ||
+              h ||
+              (Xt !== null && Xt.memoizedState.tag & 1))
+          ) {
+            if (
+              ((a.flags |= 2048),
+              Pa(9, fu(), Xo.bind(null, a, l, n, e), null),
+              Mt === null)
+            )
+              throw Error(f(349))
+            s || (Dn & 124) !== 0 || Go(a, e, n)
+          }
+          return n
+        }
+        function Go(t, e, n) {
+          ;((t.flags |= 16384),
+            (t = { getSnapshot: e, value: n }),
+            (e = gt.updateQueue),
+            e === null
+              ? ((e = fs()), (gt.updateQueue = e), (e.stores = [t]))
+              : ((n = e.stores), n === null ? (e.stores = [t]) : n.push(t)))
+        }
+        function Xo(t, e, n, a) {
+          ;((e.value = n), (e.getSnapshot = a), Io(e) && Zo(t))
+        }
+        function Vo(t, e, n) {
+          return n(function () {
+            Io(e) && Zo(t)
+          })
+        }
+        function Io(t) {
+          var e = t.getSnapshot
+          t = t.value
+          try {
+            var n = e()
+            return !ye(t, n)
+          } catch {
+            return !0
+          }
+        }
+        function Zo(t) {
+          var e = Va(t, 2)
+          e !== null && Te(e, t, 2)
+        }
+        function hs(t) {
+          var e = de()
+          if (typeof t == 'function') {
+            var n = t
+            if (((t = n()), Aa)) {
+              pn(!0)
+              try {
+                n()
+              } finally {
+                pn(!1)
+              }
+            }
+          }
+          return (
+            (e.memoizedState = e.baseState = t),
+            (e.queue = {
+              pending: null,
+              lanes: 0,
+              dispatch: null,
+              lastRenderedReducer: an,
+              lastRenderedState: t,
+            }),
+            e
+          )
+        }
+        function qo(t, e, n, a) {
+          return ((t.baseState = n), os(t, wt, typeof a == 'function' ? a : an))
+        }
+        function lm(t, e, n, a, l) {
+          if (ou(t)) throw Error(f(485))
+          if (((t = e.action), t !== null)) {
+            var s = {
+              payload: l,
+              action: t,
+              next: null,
+              isTransition: !0,
+              status: 'pending',
+              value: null,
+              reason: null,
+              listeners: [],
+              then: function (h) {
+                s.listeners.push(h)
+              },
+            }
+            ;(M.T !== null ? n(!0) : (s.isTransition = !1),
+              a(s),
+              (n = e.pending),
+              n === null
+                ? ((s.next = e.pending = s), ko(e, s))
+                : ((s.next = n.next), (e.pending = n.next = s)))
+          }
+        }
+        function ko(t, e) {
+          var n = e.action,
+            a = e.payload,
+            l = t.state
+          if (e.isTransition) {
+            var s = M.T,
+              h = {}
+            M.T = h
+            try {
+              var g = n(l, a),
+                S = M.S
+              ;(S !== null && S(h, g), Ko(t, e, g))
+            } catch (B) {
+              gs(t, e, B)
+            } finally {
+              M.T = s
+            }
+          } else
+            try {
+              ;((s = n(l, a)), Ko(t, e, s))
+            } catch (B) {
+              gs(t, e, B)
+            }
+        }
+        function Ko(t, e, n) {
+          n !== null && typeof n == 'object' && typeof n.then == 'function'
+            ? n.then(
+                function (a) {
+                  Wo(t, e, a)
+                },
+                function (a) {
+                  return gs(t, e, a)
+                },
+              )
+            : Wo(t, e, n)
+        }
+        function Wo(t, e, n) {
+          ;((e.status = 'fulfilled'),
+            (e.value = n),
+            Fo(e),
+            (t.state = n),
+            (e = t.pending),
+            e !== null &&
+              ((n = e.next),
+              n === e
+                ? (t.pending = null)
+                : ((n = n.next), (e.next = n), ko(t, n))))
+        }
+        function gs(t, e, n) {
+          var a = t.pending
+          if (((t.pending = null), a !== null)) {
+            a = a.next
+            do ((e.status = 'rejected'), (e.reason = n), Fo(e), (e = e.next))
+            while (e !== a)
+          }
+          t.action = null
+        }
+        function Fo(t) {
+          t = t.listeners
+          for (var e = 0; e < t.length; e++) (0, t[e])()
+        }
+        function Jo(t, e) {
+          return e
+        }
+        function Po(t, e) {
+          if (xt) {
+            var n = Mt.formState
+            if (n !== null) {
+              t: {
+                var a = gt
+                if (xt) {
+                  if (Yt) {
+                    e: {
+                      for (var l = Yt, s = Ve; l.nodeType !== 8; ) {
+                        if (!s) {
+                          l = null
+                          break e
+                        }
+                        if (((l = Xe(l.nextSibling)), l === null)) {
+                          l = null
+                          break e
+                        }
+                      }
+                      ;((s = l.data), (l = s === 'F!' || s === 'F' ? l : null))
+                    }
+                    if (l) {
+                      ;((Yt = Xe(l.nextSibling)), (a = l.data === 'F!'))
+                      break t
+                    }
+                  }
+                  da(a)
+                }
+                a = !1
+              }
+              a && (e = n[0])
+            }
+          }
+          return (
+            (n = de()),
+            (n.memoizedState = n.baseState = e),
+            (a = {
+              pending: null,
+              lanes: 0,
+              dispatch: null,
+              lastRenderedReducer: Jo,
+              lastRenderedState: e,
+            }),
+            (n.queue = a),
+            (n = A0.bind(null, gt, a)),
+            (a.dispatch = n),
+            (a = hs(!1)),
+            (s = Es.bind(null, gt, !1, a.queue)),
+            (a = de()),
+            (l = { state: e, dispatch: null, action: t, pending: null }),
+            (a.queue = l),
+            (n = lm.bind(null, gt, l, s, n)),
+            (l.dispatch = n),
+            (a.memoizedState = t),
+            [e, n, !1]
+          )
+        }
+        function _o(t) {
+          var e = Vt()
+          return $o(e, wt, t)
+        }
+        function $o(t, e, n) {
+          if (
+            ((e = os(t, e, Jo)[0]),
+            (t = su(an)[0]),
+            typeof e == 'object' && e !== null && typeof e.then == 'function')
+          )
+            try {
+              var a = ql(e)
+            } catch (h) {
+              throw h === zl ? nu : h
+            }
+          else a = e
+          e = Vt()
+          var l = e.queue,
+            s = l.dispatch
+          return (
+            n !== e.memoizedState &&
+              ((gt.flags |= 2048), Pa(9, fu(), im.bind(null, l, n), null)),
+            [a, s, t]
+          )
+        }
+        function im(t, e) {
+          t.action = e
+        }
+        function t0(t) {
+          var e = Vt(),
+            n = wt
+          if (n !== null) return $o(e, n, t)
+          ;(Vt(), (e = e.memoizedState), (n = Vt()))
+          var a = n.queue.dispatch
+          return ((n.memoizedState = t), [e, a, !1])
+        }
+        function Pa(t, e, n, a) {
+          return (
+            (t = { tag: t, create: n, deps: a, inst: e, next: null }),
+            (e = gt.updateQueue),
+            e === null && ((e = fs()), (gt.updateQueue = e)),
+            (n = e.lastEffect),
+            n === null
+              ? (e.lastEffect = t.next = t)
+              : ((a = n.next), (n.next = t), (t.next = a), (e.lastEffect = t)),
+            t
+          )
+        }
+        function fu() {
+          return { destroy: void 0, resource: void 0 }
+        }
+        function e0() {
+          return Vt().memoizedState
+        }
+        function ru(t, e, n, a) {
+          var l = de()
+          ;((a = a === void 0 ? null : a),
+            (gt.flags |= t),
+            (l.memoizedState = Pa(1 | e, fu(), n, a)))
+        }
+        function kl(t, e, n, a) {
+          var l = Vt()
+          a = a === void 0 ? null : a
+          var s = l.memoizedState.inst
+          wt !== null && a !== null && ls(a, wt.memoizedState.deps)
+            ? (l.memoizedState = Pa(e, s, n, a))
+            : ((gt.flags |= t), (l.memoizedState = Pa(1 | e, s, n, a)))
+        }
+        function n0(t, e) {
+          ru(8390656, 8, t, e)
+        }
+        function a0(t, e) {
+          kl(2048, 8, t, e)
+        }
+        function l0(t, e) {
+          return kl(4, 2, t, e)
+        }
+        function i0(t, e) {
+          return kl(4, 4, t, e)
+        }
+        function u0(t, e) {
+          if (typeof e == 'function') {
+            t = t()
+            var n = e(t)
+            return function () {
+              typeof n == 'function' ? n() : e(null)
+            }
+          }
+          if (e != null)
+            return (
+              (t = t()),
+              (e.current = t),
+              function () {
+                e.current = null
+              }
+            )
+        }
+        function c0(t, e, n) {
+          ;((n = n != null ? n.concat([t]) : null),
+            kl(4, 4, u0.bind(null, e, t), n))
+        }
+        function ms() {}
+        function s0(t, e) {
+          var n = Vt()
+          e = e === void 0 ? null : e
+          var a = n.memoizedState
+          return e !== null && ls(e, a[1])
+            ? a[0]
+            : ((n.memoizedState = [t, e]), t)
+        }
+        function f0(t, e) {
+          var n = Vt()
+          e = e === void 0 ? null : e
+          var a = n.memoizedState
+          if (e !== null && ls(e, a[1])) return a[0]
+          if (((a = t()), Aa)) {
+            pn(!0)
+            try {
+              t()
+            } finally {
+              pn(!1)
+            }
+          }
+          return ((n.memoizedState = [a, e]), a)
+        }
+        function As(t, e, n) {
+          return n === void 0 || (Dn & 1073741824) !== 0
+            ? (t.memoizedState = e)
+            : ((t.memoizedState = n), (t = dd()), (gt.lanes |= t), (Un |= t), n)
+        }
+        function r0(t, e, n, a) {
+          return ye(n, e)
+            ? n
+            : Wa.current !== null
+              ? ((t = As(t, n, a)), ye(t, e) || (Kt = !0), t)
+              : (Dn & 42) === 0
+                ? ((Kt = !0), (t.memoizedState = n))
+                : ((t = dd()), (gt.lanes |= t), (Un |= t), e)
+        }
+        function o0(t, e, n, a, l) {
+          var s = _.p
+          _.p = s !== 0 && 8 > s ? s : 8
+          var h = M.T,
+            g = {}
+          ;((M.T = g), Es(t, !1, e, n))
+          try {
+            var S = l(),
+              B = M.S
+            if (
+              (B !== null && B(g, S),
+              S !== null && typeof S == 'object' && typeof S.then == 'function')
+            ) {
+              var X = em(S, a)
+              Kl(t, e, X, Se(t))
+            } else Kl(t, e, a, Se(t))
+          } catch (k) {
+            Kl(
+              t,
+              e,
+              { then: function () {}, status: 'rejected', reason: k },
+              Se(),
+            )
+          } finally {
+            ;((_.p = s), (M.T = h))
+          }
+        }
+        function um() {}
+        function vs(t, e, n, a) {
+          if (t.tag !== 5) throw Error(f(476))
+          var l = d0(t).queue
+          o0(
+            t,
+            l,
+            e,
+            $,
+            n === null
+              ? um
+              : function () {
+                  return (h0(t), n(a))
+                },
+          )
+        }
+        function d0(t) {
+          var e = t.memoizedState
+          if (e !== null) return e
+          e = {
+            memoizedState: $,
+            baseState: $,
+            baseQueue: null,
+            queue: {
+              pending: null,
+              lanes: 0,
+              dispatch: null,
+              lastRenderedReducer: an,
+              lastRenderedState: $,
+            },
+            next: null,
+          }
+          var n = {}
+          return (
+            (e.next = {
+              memoizedState: n,
+              baseState: n,
+              baseQueue: null,
+              queue: {
+                pending: null,
+                lanes: 0,
+                dispatch: null,
+                lastRenderedReducer: an,
+                lastRenderedState: n,
+              },
+              next: null,
+            }),
+            (t.memoizedState = e),
+            (t = t.alternate),
+            t !== null && (t.memoizedState = e),
+            e
+          )
+        }
+        function h0(t) {
+          var e = d0(t).next.queue
+          Kl(t, e, {}, Se())
+        }
+        function ys() {
+          return ae(oi)
+        }
+        function g0() {
+          return Vt().memoizedState
+        }
+        function m0() {
+          return Vt().memoizedState
+        }
+        function cm(t) {
+          for (var e = t.return; e !== null; ) {
+            switch (e.tag) {
+              case 24:
+              case 3:
+                var n = Se()
+                t = Rn(n)
+                var a = On(e, t, n)
+                ;(a !== null && (Te(a, e, n), Xl(a, e, n)),
+                  (e = { cache: Wc() }),
+                  (t.payload = e))
+                return
+            }
+            e = e.return
+          }
+        }
+        function sm(t, e, n) {
+          var a = Se()
+          ;((n = {
+            lane: a,
+            revertLane: 0,
+            action: n,
+            hasEagerState: !1,
+            eagerState: null,
+            next: null,
+          }),
+            ou(t)
+              ? v0(e, n)
+              : ((n = Lc(t, e, n, a)),
+                n !== null && (Te(n, t, a), y0(n, e, a))))
+        }
+        function A0(t, e, n) {
+          var a = Se()
+          Kl(t, e, n, a)
+        }
+        function Kl(t, e, n, a) {
+          var l = {
+            lane: a,
+            revertLane: 0,
+            action: n,
+            hasEagerState: !1,
+            eagerState: null,
+            next: null,
+          }
+          if (ou(t)) v0(e, l)
+          else {
+            var s = t.alternate
+            if (
+              t.lanes === 0 &&
+              (s === null || s.lanes === 0) &&
+              ((s = e.lastRenderedReducer), s !== null)
+            )
+              try {
+                var h = e.lastRenderedState,
+                  g = s(h, n)
+                if (((l.hasEagerState = !0), (l.eagerState = g), ye(g, h)))
+                  return (Wi(t, e, l, 0), Mt === null && Ki(), !1)
+              } catch {
+              } finally {
+              }
+            if (((n = Lc(t, e, l, a)), n !== null))
+              return (Te(n, t, a), y0(n, e, a), !0)
+          }
+          return !1
+        }
+        function Es(t, e, n, a) {
+          if (
+            ((a = {
+              lane: 2,
+              revertLane: Ps(),
+              action: a,
+              hasEagerState: !1,
+              eagerState: null,
+              next: null,
+            }),
+            ou(t))
+          ) {
+            if (e) throw Error(f(479))
+          } else ((e = Lc(t, n, a, 2)), e !== null && Te(e, t, 2))
+        }
+        function ou(t) {
+          var e = t.alternate
+          return t === gt || (e !== null && e === gt)
+        }
+        function v0(t, e) {
+          Fa = iu = !0
+          var n = t.pending
+          ;(n === null ? (e.next = e) : ((e.next = n.next), (n.next = e)),
+            (t.pending = e))
+        }
+        function y0(t, e, n) {
+          if ((n & 4194048) !== 0) {
+            var a = e.lanes
+            ;((a &= t.pendingLanes), (n |= a), (e.lanes = n), wr(t, n))
+          }
+        }
+        var du = {
+            readContext: ae,
+            use: cu,
+            useCallback: zt,
+            useContext: zt,
+            useEffect: zt,
+            useImperativeHandle: zt,
+            useLayoutEffect: zt,
+            useInsertionEffect: zt,
+            useMemo: zt,
+            useReducer: zt,
+            useRef: zt,
+            useState: zt,
+            useDebugValue: zt,
+            useDeferredValue: zt,
+            useTransition: zt,
+            useSyncExternalStore: zt,
+            useId: zt,
+            useHostTransitionStatus: zt,
+            useFormState: zt,
+            useActionState: zt,
+            useOptimistic: zt,
+            useMemoCache: zt,
+            useCacheRefresh: zt,
+          },
+          E0 = {
+            readContext: ae,
+            use: cu,
+            useCallback: function (t, e) {
+              return ((de().memoizedState = [t, e === void 0 ? null : e]), t)
+            },
+            useContext: ae,
+            useEffect: n0,
+            useImperativeHandle: function (t, e, n) {
+              ;((n = n != null ? n.concat([t]) : null),
+                ru(4194308, 4, u0.bind(null, e, t), n))
+            },
+            useLayoutEffect: function (t, e) {
+              return ru(4194308, 4, t, e)
+            },
+            useInsertionEffect: function (t, e) {
+              ru(4, 2, t, e)
+            },
+            useMemo: function (t, e) {
+              var n = de()
+              e = e === void 0 ? null : e
+              var a = t()
+              if (Aa) {
+                pn(!0)
+                try {
+                  t()
+                } finally {
+                  pn(!1)
+                }
+              }
+              return ((n.memoizedState = [a, e]), a)
+            },
+            useReducer: function (t, e, n) {
+              var a = de()
+              if (n !== void 0) {
+                var l = n(e)
+                if (Aa) {
+                  pn(!0)
+                  try {
+                    n(e)
+                  } finally {
+                    pn(!1)
+                  }
+                }
+              } else l = e
+              return (
+                (a.memoizedState = a.baseState = l),
+                (t = {
+                  pending: null,
+                  lanes: 0,
+                  dispatch: null,
+                  lastRenderedReducer: t,
+                  lastRenderedState: l,
+                }),
+                (a.queue = t),
+                (t = t.dispatch = sm.bind(null, gt, t)),
+                [a.memoizedState, t]
+              )
+            },
+            useRef: function (t) {
+              var e = de()
+              return ((t = { current: t }), (e.memoizedState = t))
+            },
+            useState: function (t) {
+              t = hs(t)
+              var e = t.queue,
+                n = A0.bind(null, gt, e)
+              return ((e.dispatch = n), [t.memoizedState, n])
+            },
+            useDebugValue: ms,
+            useDeferredValue: function (t, e) {
+              var n = de()
+              return As(n, t, e)
+            },
+            useTransition: function () {
+              var t = hs(!1)
+              return (
+                (t = o0.bind(null, gt, t.queue, !0, !1)),
+                (de().memoizedState = t),
+                [!1, t]
+              )
+            },
+            useSyncExternalStore: function (t, e, n) {
+              var a = gt,
+                l = de()
+              if (xt) {
+                if (n === void 0) throw Error(f(407))
+                n = n()
+              } else {
+                if (((n = e()), Mt === null)) throw Error(f(349))
+                ;(Et & 124) !== 0 || Go(a, e, n)
+              }
+              l.memoizedState = n
+              var s = { value: n, getSnapshot: e }
+              return (
+                (l.queue = s),
+                n0(Vo.bind(null, a, s, t), [t]),
+                (a.flags |= 2048),
+                Pa(9, fu(), Xo.bind(null, a, s, n, e), null),
+                n
+              )
+            },
+            useId: function () {
+              var t = de(),
+                e = Mt.identifierPrefix
+              if (xt) {
+                var n = tn,
+                  a = $e
+                ;((n = (a & ~(1 << (32 - ve(a) - 1))).toString(32) + n),
+                  (e = '«' + e + 'R' + n),
+                  (n = uu++),
+                  0 < n && (e += 'H' + n.toString(32)),
+                  (e += '»'))
+              } else ((n = nm++), (e = '«' + e + 'r' + n.toString(32) + '»'))
+              return (t.memoizedState = e)
+            },
+            useHostTransitionStatus: ys,
+            useFormState: Po,
+            useActionState: Po,
+            useOptimistic: function (t) {
+              var e = de()
+              e.memoizedState = e.baseState = t
+              var n = {
+                pending: null,
+                lanes: 0,
+                dispatch: null,
+                lastRenderedReducer: null,
+                lastRenderedState: null,
+              }
+              return (
+                (e.queue = n),
+                (e = Es.bind(null, gt, !0, n)),
+                (n.dispatch = e),
+                [t, e]
+              )
+            },
+            useMemoCache: rs,
+            useCacheRefresh: function () {
+              return (de().memoizedState = cm.bind(null, gt))
+            },
+          },
+          b0 = {
+            readContext: ae,
+            use: cu,
+            useCallback: s0,
+            useContext: ae,
+            useEffect: a0,
+            useImperativeHandle: c0,
+            useInsertionEffect: l0,
+            useLayoutEffect: i0,
+            useMemo: f0,
+            useReducer: su,
+            useRef: e0,
+            useState: function () {
+              return su(an)
+            },
+            useDebugValue: ms,
+            useDeferredValue: function (t, e) {
+              var n = Vt()
+              return r0(n, wt.memoizedState, t, e)
+            },
+            useTransition: function () {
+              var t = su(an)[0],
+                e = Vt().memoizedState
+              return [typeof t == 'boolean' ? t : ql(t), e]
+            },
+            useSyncExternalStore: zo,
+            useId: g0,
+            useHostTransitionStatus: ys,
+            useFormState: _o,
+            useActionState: _o,
+            useOptimistic: function (t, e) {
+              var n = Vt()
+              return qo(n, wt, t, e)
+            },
+            useMemoCache: rs,
+            useCacheRefresh: m0,
+          },
+          fm = {
+            readContext: ae,
+            use: cu,
+            useCallback: s0,
+            useContext: ae,
+            useEffect: a0,
+            useImperativeHandle: c0,
+            useInsertionEffect: l0,
+            useLayoutEffect: i0,
+            useMemo: f0,
+            useReducer: ds,
+            useRef: e0,
+            useState: function () {
+              return ds(an)
+            },
+            useDebugValue: ms,
+            useDeferredValue: function (t, e) {
+              var n = Vt()
+              return wt === null ? As(n, t, e) : r0(n, wt.memoizedState, t, e)
+            },
+            useTransition: function () {
+              var t = ds(an)[0],
+                e = Vt().memoizedState
+              return [typeof t == 'boolean' ? t : ql(t), e]
+            },
+            useSyncExternalStore: zo,
+            useId: g0,
+            useHostTransitionStatus: ys,
+            useFormState: t0,
+            useActionState: t0,
+            useOptimistic: function (t, e) {
+              var n = Vt()
+              return wt !== null
+                ? qo(n, wt, t, e)
+                : ((n.baseState = t), [t, n.queue.dispatch])
+            },
+            useMemoCache: rs,
+            useCacheRefresh: m0,
+          },
+          _a = null,
+          Wl = 0
+        function hu(t) {
+          var e = Wl
+          return ((Wl += 1), _a === null && (_a = []), jo(_a, t, e))
+        }
+        function Fl(t, e) {
+          ;((e = e.props.ref), (t.ref = e !== void 0 ? e : null))
+        }
+        function gu(t, e) {
+          throw e.$$typeof === w
+            ? Error(f(525))
+            : ((t = Object.prototype.toString.call(e)),
+              Error(
+                f(
+                  31,
+                  t === '[object Object]'
+                    ? 'object with keys {' + Object.keys(e).join(', ') + '}'
+                    : t,
+                ),
+              ))
+        }
+        function p0(t) {
+          var e = t._init
+          return e(t._payload)
+        }
+        function x0(t) {
+          function e(C, O) {
+            if (t) {
+              var H = C.deletions
+              H === null ? ((C.deletions = [O]), (C.flags |= 16)) : H.push(O)
+            }
+          }
+          function n(C, O) {
+            if (!t) return null
+            for (; O !== null; ) (e(C, O), (O = O.sibling))
+            return null
+          }
+          function a(C) {
+            for (var O = new Map(); C !== null; )
+              (C.key !== null ? O.set(C.key, C) : O.set(C.index, C),
+                (C = C.sibling))
+            return O
+          }
+          function l(C, O) {
+            return ((C = _e(C, O)), (C.index = 0), (C.sibling = null), C)
+          }
+          function s(C, O, H) {
+            return (
+              (C.index = H),
+              t
+                ? ((H = C.alternate),
+                  H !== null
+                    ? ((H = H.index), H < O ? ((C.flags |= 67108866), O) : H)
+                    : ((C.flags |= 67108866), O))
+                : ((C.flags |= 1048576), O)
+            )
+          }
+          function h(C) {
+            return (t && C.alternate === null && (C.flags |= 67108866), C)
+          }
+          function g(C, O, H, Z) {
+            return O === null || O.tag !== 6
+              ? ((O = Gc(H, C.mode, Z)), (O.return = C), O)
+              : ((O = l(O, H)), (O.return = C), O)
+          }
+          function S(C, O, H, Z) {
+            var nt = H.type
+            return nt === N
+              ? X(C, O, H.props.children, Z, H.key)
+              : O !== null &&
+                  (O.elementType === nt ||
+                    (typeof nt == 'object' &&
+                      nt !== null &&
+                      nt.$$typeof === L &&
+                      p0(nt) === O.type))
+                ? ((O = l(O, H.props)), Fl(O, H), (O.return = C), O)
+                : ((O = Ji(H.type, H.key, H.props, null, C.mode, Z)),
+                  Fl(O, H),
+                  (O.return = C),
+                  O)
+          }
+          function B(C, O, H, Z) {
+            return O === null ||
+              O.tag !== 4 ||
+              O.stateNode.containerInfo !== H.containerInfo ||
+              O.stateNode.implementation !== H.implementation
+              ? ((O = Xc(H, C.mode, Z)), (O.return = C), O)
+              : ((O = l(O, H.children || [])), (O.return = C), O)
+          }
+          function X(C, O, H, Z, nt) {
+            return O === null || O.tag !== 7
+              ? ((O = sa(H, C.mode, Z, nt)), (O.return = C), O)
+              : ((O = l(O, H)), (O.return = C), O)
+          }
+          function k(C, O, H) {
+            if (
+              (typeof O == 'string' && O !== '') ||
+              typeof O == 'number' ||
+              typeof O == 'bigint'
+            )
+              return ((O = Gc('' + O, C.mode, H)), (O.return = C), O)
+            if (typeof O == 'object' && O !== null) {
+              switch (O.$$typeof) {
+                case R:
+                  return (
+                    (H = Ji(O.type, O.key, O.props, null, C.mode, H)),
+                    Fl(H, O),
+                    (H.return = C),
+                    H
+                  )
+                case z:
+                  return ((O = Xc(O, C.mode, H)), (O.return = C), O)
+                case L:
+                  var Z = O._init
+                  return ((O = Z(O._payload)), k(C, O, H))
+              }
+              if (at(O) || et(O))
+                return ((O = sa(O, C.mode, H, null)), (O.return = C), O)
+              if (typeof O.then == 'function') return k(C, hu(O), H)
+              if (O.$$typeof === U) return k(C, tu(C, O), H)
+              gu(C, O)
+            }
+            return null
+          }
+          function Q(C, O, H, Z) {
+            var nt = O !== null ? O.key : null
+            if (
+              (typeof H == 'string' && H !== '') ||
+              typeof H == 'number' ||
+              typeof H == 'bigint'
+            )
+              return nt !== null ? null : g(C, O, '' + H, Z)
+            if (typeof H == 'object' && H !== null) {
+              switch (H.$$typeof) {
+                case R:
+                  return H.key === nt ? S(C, O, H, Z) : null
+                case z:
+                  return H.key === nt ? B(C, O, H, Z) : null
+                case L:
+                  return ((nt = H._init), (H = nt(H._payload)), Q(C, O, H, Z))
+              }
+              if (at(H) || et(H))
+                return nt !== null ? null : X(C, O, H, Z, null)
+              if (typeof H.then == 'function') return Q(C, O, hu(H), Z)
+              if (H.$$typeof === U) return Q(C, O, tu(C, H), Z)
+              gu(C, H)
+            }
+            return null
+          }
+          function Y(C, O, H, Z, nt) {
+            if (
+              (typeof Z == 'string' && Z !== '') ||
+              typeof Z == 'number' ||
+              typeof Z == 'bigint'
+            )
+              return ((C = C.get(H) || null), g(O, C, '' + Z, nt))
+            if (typeof Z == 'object' && Z !== null) {
+              switch (Z.$$typeof) {
+                case R:
+                  return (
+                    (C = C.get(Z.key === null ? H : Z.key) || null),
+                    S(O, C, Z, nt)
+                  )
+                case z:
+                  return (
+                    (C = C.get(Z.key === null ? H : Z.key) || null),
+                    B(O, C, Z, nt)
+                  )
+                case L:
+                  var At = Z._init
+                  return ((Z = At(Z._payload)), Y(C, O, H, Z, nt))
+              }
+              if (at(Z) || et(Z))
+                return ((C = C.get(H) || null), X(O, C, Z, nt, null))
+              if (typeof Z.then == 'function') return Y(C, O, H, hu(Z), nt)
+              if (Z.$$typeof === U) return Y(C, O, H, tu(O, Z), nt)
+              gu(O, Z)
+            }
+            return null
+          }
+          function rt(C, O, H, Z) {
+            for (
+              var nt = null, At = null, lt = O, ft = (O = 0), Ft = null;
+              lt !== null && ft < H.length;
+              ft++
+            ) {
+              lt.index > ft ? ((Ft = lt), (lt = null)) : (Ft = lt.sibling)
+              var pt = Q(C, lt, H[ft], Z)
+              if (pt === null) {
+                lt === null && (lt = Ft)
+                break
+              }
+              ;(t && lt && pt.alternate === null && e(C, lt),
+                (O = s(pt, O, ft)),
+                At === null ? (nt = pt) : (At.sibling = pt),
+                (At = pt),
+                (lt = Ft))
+            }
+            if (ft === H.length) return (n(C, lt), xt && ra(C, ft), nt)
+            if (lt === null) {
+              for (; ft < H.length; ft++)
+                ((lt = k(C, H[ft], Z)),
+                  lt !== null &&
+                    ((O = s(lt, O, ft)),
+                    At === null ? (nt = lt) : (At.sibling = lt),
+                    (At = lt)))
+              return (xt && ra(C, ft), nt)
+            }
+            for (lt = a(lt); ft < H.length; ft++)
+              ((Ft = Y(lt, C, ft, H[ft], Z)),
+                Ft !== null &&
+                  (t &&
+                    Ft.alternate !== null &&
+                    lt.delete(Ft.key === null ? ft : Ft.key),
+                  (O = s(Ft, O, ft)),
+                  At === null ? (nt = Ft) : (At.sibling = Ft),
+                  (At = Ft)))
+            return (
+              t &&
+                lt.forEach(function (Zn) {
+                  return e(C, Zn)
+                }),
+              xt && ra(C, ft),
+              nt
+            )
+          }
+          function st(C, O, H, Z) {
+            if (H == null) throw Error(f(151))
+            for (
+              var nt = null,
+                At = null,
+                lt = O,
+                ft = (O = 0),
+                Ft = null,
+                pt = H.next();
+              lt !== null && !pt.done;
+              ft++, pt = H.next()
+            ) {
+              lt.index > ft ? ((Ft = lt), (lt = null)) : (Ft = lt.sibling)
+              var Zn = Q(C, lt, pt.value, Z)
+              if (Zn === null) {
+                lt === null && (lt = Ft)
+                break
+              }
+              ;(t && lt && Zn.alternate === null && e(C, lt),
+                (O = s(Zn, O, ft)),
+                At === null ? (nt = Zn) : (At.sibling = Zn),
+                (At = Zn),
+                (lt = Ft))
+            }
+            if (pt.done) return (n(C, lt), xt && ra(C, ft), nt)
+            if (lt === null) {
+              for (; !pt.done; ft++, pt = H.next())
+                ((pt = k(C, pt.value, Z)),
+                  pt !== null &&
+                    ((O = s(pt, O, ft)),
+                    At === null ? (nt = pt) : (At.sibling = pt),
+                    (At = pt)))
+              return (xt && ra(C, ft), nt)
+            }
+            for (lt = a(lt); !pt.done; ft++, pt = H.next())
+              ((pt = Y(lt, C, ft, pt.value, Z)),
+                pt !== null &&
+                  (t &&
+                    pt.alternate !== null &&
+                    lt.delete(pt.key === null ? ft : pt.key),
+                  (O = s(pt, O, ft)),
+                  At === null ? (nt = pt) : (At.sibling = pt),
+                  (At = pt)))
+            return (
+              t &&
+                lt.forEach(function (rA) {
+                  return e(C, rA)
+                }),
+              xt && ra(C, ft),
+              nt
+            )
+          }
+          function Ot(C, O, H, Z) {
+            if (
+              (typeof H == 'object' &&
+                H !== null &&
+                H.type === N &&
+                H.key === null &&
+                (H = H.props.children),
+              typeof H == 'object' && H !== null)
+            ) {
+              switch (H.$$typeof) {
+                case R:
+                  t: {
+                    for (var nt = H.key; O !== null; ) {
+                      if (O.key === nt) {
+                        if (((nt = H.type), nt === N)) {
+                          if (O.tag === 7) {
+                            ;(n(C, O.sibling),
+                              (Z = l(O, H.props.children)),
+                              (Z.return = C),
+                              (C = Z))
+                            break t
+                          }
+                        } else if (
+                          O.elementType === nt ||
+                          (typeof nt == 'object' &&
+                            nt !== null &&
+                            nt.$$typeof === L &&
+                            p0(nt) === O.type)
+                        ) {
+                          ;(n(C, O.sibling),
+                            (Z = l(O, H.props)),
+                            Fl(Z, H),
+                            (Z.return = C),
+                            (C = Z))
+                          break t
+                        }
+                        n(C, O)
+                        break
+                      } else e(C, O)
+                      O = O.sibling
+                    }
+                    H.type === N
+                      ? ((Z = sa(H.props.children, C.mode, Z, H.key)),
+                        (Z.return = C),
+                        (C = Z))
+                      : ((Z = Ji(H.type, H.key, H.props, null, C.mode, Z)),
+                        Fl(Z, H),
+                        (Z.return = C),
+                        (C = Z))
+                  }
+                  return h(C)
+                case z:
+                  t: {
+                    for (nt = H.key; O !== null; ) {
+                      if (O.key === nt)
+                        if (
+                          O.tag === 4 &&
+                          O.stateNode.containerInfo === H.containerInfo &&
+                          O.stateNode.implementation === H.implementation
+                        ) {
+                          ;(n(C, O.sibling),
+                            (Z = l(O, H.children || [])),
+                            (Z.return = C),
+                            (C = Z))
+                          break t
+                        } else {
+                          n(C, O)
+                          break
+                        }
+                      else e(C, O)
+                      O = O.sibling
+                    }
+                    ;((Z = Xc(H, C.mode, Z)), (Z.return = C), (C = Z))
+                  }
+                  return h(C)
+                case L:
+                  return ((nt = H._init), (H = nt(H._payload)), Ot(C, O, H, Z))
+              }
+              if (at(H)) return rt(C, O, H, Z)
+              if (et(H)) {
+                if (((nt = et(H)), typeof nt != 'function')) throw Error(f(150))
+                return ((H = nt.call(H)), st(C, O, H, Z))
+              }
+              if (typeof H.then == 'function') return Ot(C, O, hu(H), Z)
+              if (H.$$typeof === U) return Ot(C, O, tu(C, H), Z)
+              gu(C, H)
+            }
+            return (typeof H == 'string' && H !== '') ||
+              typeof H == 'number' ||
+              typeof H == 'bigint'
+              ? ((H = '' + H),
+                O !== null && O.tag === 6
+                  ? (n(C, O.sibling), (Z = l(O, H)), (Z.return = C), (C = Z))
+                  : (n(C, O), (Z = Gc(H, C.mode, Z)), (Z.return = C), (C = Z)),
+                h(C))
+              : n(C, O)
+          }
+          return function (C, O, H, Z) {
+            try {
+              Wl = 0
+              var nt = Ot(C, O, H, Z)
+              return ((_a = null), nt)
+            } catch (lt) {
+              if (lt === zl || lt === nu) throw lt
+              var At = Ee(29, lt, null, C.mode)
+              return ((At.lanes = Z), (At.return = C), At)
+            } finally {
+            }
+          }
+        }
+        var $a = x0(!0),
+          S0 = x0(!1),
+          He = q(null),
+          Ie = null
+        function Cn(t) {
+          var e = t.alternate
+          ;(J(Zt, Zt.current & 1),
+            J(He, t),
+            Ie === null &&
+              (e === null || Wa.current !== null || e.memoizedState !== null) &&
+              (Ie = t))
+        }
+        function T0(t) {
+          if (t.tag === 22) {
+            if ((J(Zt, Zt.current), J(He, t), Ie === null)) {
+              var e = t.alternate
+              e !== null && e.memoizedState !== null && (Ie = t)
+            }
+          } else Mn()
+        }
+        function Mn() {
+          ;(J(Zt, Zt.current), J(He, He.current))
+        }
+        function ln(t) {
+          ;(P(He), Ie === t && (Ie = null), P(Zt))
+        }
+        var Zt = q(0)
+        function mu(t) {
+          for (var e = t; e !== null; ) {
+            if (e.tag === 13) {
+              var n = e.memoizedState
+              if (
+                n !== null &&
+                ((n = n.dehydrated), n === null || n.data === '$?' || rf(n))
+              )
+                return e
+            } else if (e.tag === 19 && e.memoizedProps.revealOrder !== void 0) {
+              if ((e.flags & 128) !== 0) return e
+            } else if (e.child !== null) {
+              ;((e.child.return = e), (e = e.child))
+              continue
+            }
+            if (e === t) break
+            for (; e.sibling === null; ) {
+              if (e.return === null || e.return === t) return null
+              e = e.return
+            }
+            ;((e.sibling.return = e.return), (e = e.sibling))
+          }
+          return null
+        }
+        function bs(t, e, n, a) {
+          ;((e = t.memoizedState),
+            (n = n(a, e)),
+            (n = n == null ? e : E({}, e, n)),
+            (t.memoizedState = n),
+            t.lanes === 0 && (t.updateQueue.baseState = n))
+        }
+        var ps = {
+          enqueueSetState: function (t, e, n) {
+            t = t._reactInternals
+            var a = Se(),
+              l = Rn(a)
+            ;((l.payload = e),
+              n != null && (l.callback = n),
+              (e = On(t, l, a)),
+              e !== null && (Te(e, t, a), Xl(e, t, a)))
+          },
+          enqueueReplaceState: function (t, e, n) {
+            t = t._reactInternals
+            var a = Se(),
+              l = Rn(a)
+            ;((l.tag = 1),
+              (l.payload = e),
+              n != null && (l.callback = n),
+              (e = On(t, l, a)),
+              e !== null && (Te(e, t, a), Xl(e, t, a)))
+          },
+          enqueueForceUpdate: function (t, e) {
+            t = t._reactInternals
+            var n = Se(),
+              a = Rn(n)
+            ;((a.tag = 2),
+              e != null && (a.callback = e),
+              (e = On(t, a, n)),
+              e !== null && (Te(e, t, n), Xl(e, t, n)))
+          },
+        }
+        function w0(t, e, n, a, l, s, h) {
+          return (
+            (t = t.stateNode),
+            typeof t.shouldComponentUpdate == 'function'
+              ? t.shouldComponentUpdate(a, s, h)
+              : e.prototype && e.prototype.isPureReactComponent
+                ? !jl(n, a) || !jl(l, s)
+                : !0
+          )
+        }
+        function R0(t, e, n, a) {
+          ;((t = e.state),
+            typeof e.componentWillReceiveProps == 'function' &&
+              e.componentWillReceiveProps(n, a),
+            typeof e.UNSAFE_componentWillReceiveProps == 'function' &&
+              e.UNSAFE_componentWillReceiveProps(n, a),
+            e.state !== t && ps.enqueueReplaceState(e, e.state, null))
+        }
+        function va(t, e) {
+          var n = e
+          if ('ref' in e) {
+            n = {}
+            for (var a in e) a !== 'ref' && (n[a] = e[a])
+          }
+          if ((t = t.defaultProps)) {
+            n === e && (n = E({}, n))
+            for (var l in t) n[l] === void 0 && (n[l] = t[l])
+          }
+          return n
+        }
+        var Au =
+          typeof reportError == 'function'
+            ? reportError
+            : function (t) {
+                if (
+                  typeof window == 'object' &&
+                  typeof window.ErrorEvent == 'function'
+                ) {
+                  var e = new window.ErrorEvent('error', {
+                    bubbles: !0,
+                    cancelable: !0,
+                    message:
+                      typeof t == 'object' &&
+                      t !== null &&
+                      typeof t.message == 'string'
+                        ? String(t.message)
+                        : String(t),
+                    error: t,
+                  })
+                  if (!window.dispatchEvent(e)) return
+                } else if (
+                  typeof process == 'object' &&
+                  typeof process.emit == 'function'
+                ) {
+                  process.emit('uncaughtException', t)
+                  return
+                }
+                console.error(t)
+              }
+        function O0(t) {
+          Au(t)
+        }
+        function D0(t) {
+          console.error(t)
+        }
+        function C0(t) {
+          Au(t)
+        }
+        function vu(t, e) {
+          try {
+            var n = t.onUncaughtError
+            n(e.value, { componentStack: e.stack })
+          } catch (a) {
+            setTimeout(function () {
+              throw a
+            })
+          }
+        }
+        function M0(t, e, n) {
+          try {
+            var a = t.onCaughtError
+            a(n.value, {
+              componentStack: n.stack,
+              errorBoundary: e.tag === 1 ? e.stateNode : null,
+            })
+          } catch (l) {
+            setTimeout(function () {
+              throw l
+            })
+          }
+        }
+        function xs(t, e, n) {
+          return (
+            (n = Rn(n)),
+            (n.tag = 3),
+            (n.payload = { element: null }),
+            (n.callback = function () {
+              vu(t, e)
+            }),
+            n
+          )
+        }
+        function j0(t) {
+          return ((t = Rn(t)), (t.tag = 3), t)
+        }
+        function H0(t, e, n, a) {
+          var l = n.type.getDerivedStateFromError
+          if (typeof l == 'function') {
+            var s = a.value
+            ;((t.payload = function () {
+              return l(s)
+            }),
+              (t.callback = function () {
+                M0(e, n, a)
+              }))
+          }
+          var h = n.stateNode
+          h !== null &&
+            typeof h.componentDidCatch == 'function' &&
+            (t.callback = function () {
+              ;(M0(e, n, a),
+                typeof l != 'function' &&
+                  (Qn === null ? (Qn = new Set([this])) : Qn.add(this)))
+              var g = a.stack
+              this.componentDidCatch(a.value, {
+                componentStack: g !== null ? g : '',
+              })
+            })
+        }
+        function rm(t, e, n, a, l) {
+          if (
+            ((n.flags |= 32768),
+            a !== null && typeof a == 'object' && typeof a.then == 'function')
+          ) {
+            if (
+              ((e = n.alternate),
+              e !== null && Ql(e, n, l, !0),
+              (n = He.current),
+              n !== null)
+            ) {
+              switch (n.tag) {
+                case 13:
+                  return (
+                    Ie === null
+                      ? ks()
+                      : n.alternate === null && Lt === 0 && (Lt = 3),
+                    (n.flags &= -257),
+                    (n.flags |= 65536),
+                    (n.lanes = l),
+                    a === Pc
+                      ? (n.flags |= 16384)
+                      : ((e = n.updateQueue),
+                        e === null ? (n.updateQueue = new Set([a])) : e.add(a),
+                        Ws(t, a, l)),
+                    !1
+                  )
+                case 22:
+                  return (
+                    (n.flags |= 65536),
+                    a === Pc
+                      ? (n.flags |= 16384)
+                      : ((e = n.updateQueue),
+                        e === null
+                          ? ((e = {
+                              transitions: null,
+                              markerInstances: null,
+                              retryQueue: new Set([a]),
+                            }),
+                            (n.updateQueue = e))
+                          : ((n = e.retryQueue),
+                            n === null
+                              ? (e.retryQueue = new Set([a]))
+                              : n.add(a)),
+                        Ws(t, a, l)),
+                    !1
+                  )
+              }
+              throw Error(f(435, n.tag))
+            }
+            return (Ws(t, a, l), ks(), !1)
+          }
+          if (xt)
+            return (
+              (e = He.current),
+              e !== null
+                ? ((e.flags & 65536) === 0 && (e.flags |= 256),
+                  (e.flags |= 65536),
+                  (e.lanes = l),
+                  a !== Zc && ((t = Error(f(422), { cause: a })), Ul(De(t, n))))
+                : (a !== Zc &&
+                    ((e = Error(f(423), { cause: a })), Ul(De(e, n))),
+                  (t = t.current.alternate),
+                  (t.flags |= 65536),
+                  (l &= -l),
+                  (t.lanes |= l),
+                  (a = De(a, n)),
+                  (l = xs(t.stateNode, a, l)),
+                  ts(t, l),
+                  Lt !== 4 && (Lt = 2)),
+              !1
+            )
+          var s = Error(f(520), { cause: a })
+          if (
+            ((s = De(s, n)),
+            ni === null ? (ni = [s]) : ni.push(s),
+            Lt !== 4 && (Lt = 2),
+            e === null)
+          )
+            return !0
+          ;((a = De(a, n)), (n = e))
+          do {
+            switch (n.tag) {
+              case 3:
+                return (
+                  (n.flags |= 65536),
+                  (t = l & -l),
+                  (n.lanes |= t),
+                  (t = xs(n.stateNode, a, t)),
+                  ts(n, t),
+                  !1
+                )
+              case 1:
+                if (
+                  ((e = n.type),
+                  (s = n.stateNode),
+                  (n.flags & 128) === 0 &&
+                    (typeof e.getDerivedStateFromError == 'function' ||
+                      (s !== null &&
+                        typeof s.componentDidCatch == 'function' &&
+                        (Qn === null || !Qn.has(s)))))
+                )
+                  return (
+                    (n.flags |= 65536),
+                    (l &= -l),
+                    (n.lanes |= l),
+                    (l = j0(l)),
+                    H0(l, t, n, a),
+                    ts(n, l),
+                    !1
+                  )
+            }
+            n = n.return
+          } while (n !== null)
+          return !1
+        }
+        var N0 = Error(f(461)),
+          Kt = !1
+        function _t(t, e, n, a) {
+          e.child = t === null ? S0(e, null, n, a) : $a(e, t.child, n, a)
+        }
+        function B0(t, e, n, a, l) {
+          n = n.render
+          var s = e.ref
+          if ('ref' in a) {
+            var h = {}
+            for (var g in a) g !== 'ref' && (h[g] = a[g])
+          } else h = a
+          return (
+            ga(e),
+            (a = is(t, e, n, h, s, l)),
+            (g = us()),
+            t !== null && !Kt
+              ? (cs(t, e, l), un(t, e, l))
+              : (xt && g && Vc(e), (e.flags |= 1), _t(t, e, a, l), e.child)
+          )
+        }
+        function U0(t, e, n, a, l) {
+          if (t === null) {
+            var s = n.type
+            return typeof s == 'function' &&
+              !zc(s) &&
+              s.defaultProps === void 0 &&
+              n.compare === null
+              ? ((e.tag = 15), (e.type = s), Q0(t, e, s, a, l))
+              : ((t = Ji(n.type, null, a, e, e.mode, l)),
+                (t.ref = e.ref),
+                (t.return = e),
+                (e.child = t))
+          }
+          if (((s = t.child), !Ms(t, l))) {
+            var h = s.memoizedProps
+            if (
+              ((n = n.compare),
+              (n = n !== null ? n : jl),
+              n(h, a) && t.ref === e.ref)
+            )
+              return un(t, e, l)
+          }
+          return (
+            (e.flags |= 1),
+            (t = _e(s, a)),
+            (t.ref = e.ref),
+            (t.return = e),
+            (e.child = t)
+          )
+        }
+        function Q0(t, e, n, a, l) {
+          if (t !== null) {
+            var s = t.memoizedProps
+            if (jl(s, a) && t.ref === e.ref)
+              if (((Kt = !1), (e.pendingProps = a = s), Ms(t, l)))
+                (t.flags & 131072) !== 0 && (Kt = !0)
+              else return ((e.lanes = t.lanes), un(t, e, l))
+          }
+          return Ss(t, e, n, a, l)
+        }
+        function Y0(t, e, n) {
+          var a = e.pendingProps,
+            l = a.children,
+            s = t !== null ? t.memoizedState : null
+          if (a.mode === 'hidden') {
+            if ((e.flags & 128) !== 0) {
+              if (((a = s !== null ? s.baseLanes | n : n), t !== null)) {
+                for (l = e.child = t.child, s = 0; l !== null; )
+                  ((s = s | l.lanes | l.childLanes), (l = l.sibling))
+                e.childLanes = s & ~a
+              } else ((e.childLanes = 0), (e.child = null))
+              return L0(t, e, a, n)
+            }
+            if ((n & 536870912) !== 0)
+              ((e.memoizedState = { baseLanes: 0, cachePool: null }),
+                t !== null && eu(e, s !== null ? s.cachePool : null),
+                s !== null ? Qo(e, s) : ns(),
+                T0(e))
+            else
+              return (
+                (e.lanes = e.childLanes = 536870912),
+                L0(t, e, s !== null ? s.baseLanes | n : n, n)
+              )
+          } else
+            s !== null
+              ? (eu(e, s.cachePool), Qo(e, s), Mn(), (e.memoizedState = null))
+              : (t !== null && eu(e, null), ns(), Mn())
+          return (_t(t, e, l, n), e.child)
+        }
+        function L0(t, e, n, a) {
+          var l = Jc()
+          return (
+            (l = l === null ? null : { parent: It._currentValue, pool: l }),
+            (e.memoizedState = { baseLanes: n, cachePool: l }),
+            t !== null && eu(e, null),
+            ns(),
+            T0(e),
+            t !== null && Ql(t, e, a, !0),
+            null
+          )
+        }
+        function yu(t, e) {
+          var n = e.ref
+          if (n === null) t !== null && t.ref !== null && (e.flags |= 4194816)
+          else {
+            if (typeof n != 'function' && typeof n != 'object')
+              throw Error(f(284))
+            ;(t === null || t.ref !== n) && (e.flags |= 4194816)
+          }
+        }
+        function Ss(t, e, n, a, l) {
+          return (
+            ga(e),
+            (n = is(t, e, n, a, void 0, l)),
+            (a = us()),
+            t !== null && !Kt
+              ? (cs(t, e, l), un(t, e, l))
+              : (xt && a && Vc(e), (e.flags |= 1), _t(t, e, n, l), e.child)
+          )
+        }
+        function z0(t, e, n, a, l, s) {
+          return (
+            ga(e),
+            (e.updateQueue = null),
+            (n = Lo(e, a, n, l)),
+            Yo(t),
+            (a = us()),
+            t !== null && !Kt
+              ? (cs(t, e, s), un(t, e, s))
+              : (xt && a && Vc(e), (e.flags |= 1), _t(t, e, n, s), e.child)
+          )
+        }
+        function G0(t, e, n, a, l) {
+          if ((ga(e), e.stateNode === null)) {
+            var s = Ia,
+              h = n.contextType
+            ;(typeof h == 'object' && h !== null && (s = ae(h)),
+              (s = new n(a, s)),
+              (e.memoizedState =
+                s.state !== null && s.state !== void 0 ? s.state : null),
+              (s.updater = ps),
+              (e.stateNode = s),
+              (s._reactInternals = e),
+              (s = e.stateNode),
+              (s.props = a),
+              (s.state = e.memoizedState),
+              (s.refs = {}),
+              _c(e),
+              (h = n.contextType),
+              (s.context = typeof h == 'object' && h !== null ? ae(h) : Ia),
+              (s.state = e.memoizedState),
+              (h = n.getDerivedStateFromProps),
+              typeof h == 'function' &&
+                (bs(e, n, h, a), (s.state = e.memoizedState)),
+              typeof n.getDerivedStateFromProps == 'function' ||
+                typeof s.getSnapshotBeforeUpdate == 'function' ||
+                (typeof s.UNSAFE_componentWillMount != 'function' &&
+                  typeof s.componentWillMount != 'function') ||
+                ((h = s.state),
+                typeof s.componentWillMount == 'function' &&
+                  s.componentWillMount(),
+                typeof s.UNSAFE_componentWillMount == 'function' &&
+                  s.UNSAFE_componentWillMount(),
+                h !== s.state && ps.enqueueReplaceState(s, s.state, null),
+                Il(e, a, s, l),
+                Vl(),
+                (s.state = e.memoizedState)),
+              typeof s.componentDidMount == 'function' && (e.flags |= 4194308),
+              (a = !0))
+          } else if (t === null) {
+            s = e.stateNode
+            var g = e.memoizedProps,
+              S = va(n, g)
+            s.props = S
+            var B = s.context,
+              X = n.contextType
+            ;((h = Ia), typeof X == 'object' && X !== null && (h = ae(X)))
+            var k = n.getDerivedStateFromProps
+            ;((X =
+              typeof k == 'function' ||
+              typeof s.getSnapshotBeforeUpdate == 'function'),
+              (g = e.pendingProps !== g),
+              X ||
+                (typeof s.UNSAFE_componentWillReceiveProps != 'function' &&
+                  typeof s.componentWillReceiveProps != 'function') ||
+                ((g || B !== h) && R0(e, s, a, h)),
+              (wn = !1))
+            var Q = e.memoizedState
+            ;((s.state = Q),
+              Il(e, a, s, l),
+              Vl(),
+              (B = e.memoizedState),
+              g || Q !== B || wn
+                ? (typeof k == 'function' &&
+                    (bs(e, n, k, a), (B = e.memoizedState)),
+                  (S = wn || w0(e, n, S, a, Q, B, h))
+                    ? (X ||
+                        (typeof s.UNSAFE_componentWillMount != 'function' &&
+                          typeof s.componentWillMount != 'function') ||
+                        (typeof s.componentWillMount == 'function' &&
+                          s.componentWillMount(),
+                        typeof s.UNSAFE_componentWillMount == 'function' &&
+                          s.UNSAFE_componentWillMount()),
+                      typeof s.componentDidMount == 'function' &&
+                        (e.flags |= 4194308))
+                    : (typeof s.componentDidMount == 'function' &&
+                        (e.flags |= 4194308),
+                      (e.memoizedProps = a),
+                      (e.memoizedState = B)),
+                  (s.props = a),
+                  (s.state = B),
+                  (s.context = h),
+                  (a = S))
+                : (typeof s.componentDidMount == 'function' &&
+                    (e.flags |= 4194308),
+                  (a = !1)))
+          } else {
+            ;((s = e.stateNode),
+              $c(t, e),
+              (h = e.memoizedProps),
+              (X = va(n, h)),
+              (s.props = X),
+              (k = e.pendingProps),
+              (Q = s.context),
+              (B = n.contextType),
+              (S = Ia),
+              typeof B == 'object' && B !== null && (S = ae(B)),
+              (g = n.getDerivedStateFromProps),
+              (B =
+                typeof g == 'function' ||
+                typeof s.getSnapshotBeforeUpdate == 'function') ||
+                (typeof s.UNSAFE_componentWillReceiveProps != 'function' &&
+                  typeof s.componentWillReceiveProps != 'function') ||
+                ((h !== k || Q !== S) && R0(e, s, a, S)),
+              (wn = !1),
+              (Q = e.memoizedState),
+              (s.state = Q),
+              Il(e, a, s, l),
+              Vl())
+            var Y = e.memoizedState
+            h !== k ||
+            Q !== Y ||
+            wn ||
+            (t !== null && t.dependencies !== null && $i(t.dependencies))
+              ? (typeof g == 'function' &&
+                  (bs(e, n, g, a), (Y = e.memoizedState)),
+                (X =
+                  wn ||
+                  w0(e, n, X, a, Q, Y, S) ||
+                  (t !== null && t.dependencies !== null && $i(t.dependencies)))
+                  ? (B ||
+                      (typeof s.UNSAFE_componentWillUpdate != 'function' &&
+                        typeof s.componentWillUpdate != 'function') ||
+                      (typeof s.componentWillUpdate == 'function' &&
+                        s.componentWillUpdate(a, Y, S),
+                      typeof s.UNSAFE_componentWillUpdate == 'function' &&
+                        s.UNSAFE_componentWillUpdate(a, Y, S)),
+                    typeof s.componentDidUpdate == 'function' && (e.flags |= 4),
+                    typeof s.getSnapshotBeforeUpdate == 'function' &&
+                      (e.flags |= 1024))
+                  : (typeof s.componentDidUpdate != 'function' ||
+                      (h === t.memoizedProps && Q === t.memoizedState) ||
+                      (e.flags |= 4),
+                    typeof s.getSnapshotBeforeUpdate != 'function' ||
+                      (h === t.memoizedProps && Q === t.memoizedState) ||
+                      (e.flags |= 1024),
+                    (e.memoizedProps = a),
+                    (e.memoizedState = Y)),
+                (s.props = a),
+                (s.state = Y),
+                (s.context = S),
+                (a = X))
+              : (typeof s.componentDidUpdate != 'function' ||
+                  (h === t.memoizedProps && Q === t.memoizedState) ||
+                  (e.flags |= 4),
+                typeof s.getSnapshotBeforeUpdate != 'function' ||
+                  (h === t.memoizedProps && Q === t.memoizedState) ||
+                  (e.flags |= 1024),
+                (a = !1))
+          }
+          return (
+            (s = a),
+            yu(t, e),
+            (a = (e.flags & 128) !== 0),
+            s || a
+              ? ((s = e.stateNode),
+                (n =
+                  a && typeof n.getDerivedStateFromError != 'function'
+                    ? null
+                    : s.render()),
+                (e.flags |= 1),
+                t !== null && a
+                  ? ((e.child = $a(e, t.child, null, l)),
+                    (e.child = $a(e, null, n, l)))
+                  : _t(t, e, n, l),
+                (e.memoizedState = s.state),
+                (t = e.child))
+              : (t = un(t, e, l)),
+            t
+          )
+        }
+        function X0(t, e, n, a) {
+          return (Bl(), (e.flags |= 256), _t(t, e, n, a), e.child)
+        }
+        var Ts = {
+          dehydrated: null,
+          treeContext: null,
+          retryLane: 0,
+          hydrationErrors: null,
+        }
+        function ws(t) {
+          return { baseLanes: t, cachePool: Do() }
+        }
+        function Rs(t, e, n) {
+          return ((t = t !== null ? t.childLanes & ~n : 0), e && (t |= Ne), t)
+        }
+        function V0(t, e, n) {
+          var a = e.pendingProps,
+            l = !1,
+            s = (e.flags & 128) !== 0,
+            h
+          if (
+            ((h = s) ||
+              (h =
+                t !== null && t.memoizedState === null
+                  ? !1
+                  : (Zt.current & 2) !== 0),
+            h && ((l = !0), (e.flags &= -129)),
+            (h = (e.flags & 32) !== 0),
+            (e.flags &= -33),
+            t === null)
+          ) {
+            if (xt) {
+              if ((l ? Cn(e) : Mn(), xt)) {
+                var g = Yt,
+                  S
+                if ((S = g)) {
+                  t: {
+                    for (S = g, g = Ve; S.nodeType !== 8; ) {
+                      if (!g) {
+                        g = null
+                        break t
+                      }
+                      if (((S = Xe(S.nextSibling)), S === null)) {
+                        g = null
+                        break t
+                      }
+                    }
+                    g = S
+                  }
+                  g !== null
+                    ? ((e.memoizedState = {
+                        dehydrated: g,
+                        treeContext:
+                          fa !== null ? { id: $e, overflow: tn } : null,
+                        retryLane: 536870912,
+                        hydrationErrors: null,
+                      }),
+                      (S = Ee(18, null, null, 0)),
+                      (S.stateNode = g),
+                      (S.return = e),
+                      (e.child = S),
+                      (se = e),
+                      (Yt = null),
+                      (S = !0))
+                    : (S = !1)
+                }
+                S || da(e)
+              }
+              if (
+                ((g = e.memoizedState),
+                g !== null && ((g = g.dehydrated), g !== null))
+              )
+                return (rf(g) ? (e.lanes = 32) : (e.lanes = 536870912), null)
+              ln(e)
+            }
+            return (
+              (g = a.children),
+              (a = a.fallback),
+              l
+                ? (Mn(),
+                  (l = e.mode),
+                  (g = Eu({ mode: 'hidden', children: g }, l)),
+                  (a = sa(a, l, n, null)),
+                  (g.return = e),
+                  (a.return = e),
+                  (g.sibling = a),
+                  (e.child = g),
+                  (l = e.child),
+                  (l.memoizedState = ws(n)),
+                  (l.childLanes = Rs(t, h, n)),
+                  (e.memoizedState = Ts),
+                  a)
+                : (Cn(e), Os(e, g))
+            )
+          }
+          if (
+            ((S = t.memoizedState),
+            S !== null && ((g = S.dehydrated), g !== null))
+          ) {
+            if (s)
+              e.flags & 256
+                ? (Cn(e), (e.flags &= -257), (e = Ds(t, e, n)))
+                : e.memoizedState !== null
+                  ? (Mn(), (e.child = t.child), (e.flags |= 128), (e = null))
+                  : (Mn(),
+                    (l = a.fallback),
+                    (g = e.mode),
+                    (a = Eu({ mode: 'visible', children: a.children }, g)),
+                    (l = sa(l, g, n, null)),
+                    (l.flags |= 2),
+                    (a.return = e),
+                    (l.return = e),
+                    (a.sibling = l),
+                    (e.child = a),
+                    $a(e, t.child, null, n),
+                    (a = e.child),
+                    (a.memoizedState = ws(n)),
+                    (a.childLanes = Rs(t, h, n)),
+                    (e.memoizedState = Ts),
+                    (e = l))
+            else if ((Cn(e), rf(g))) {
+              if (((h = g.nextSibling && g.nextSibling.dataset), h))
+                var B = h.dgst
+              ;((h = B),
+                (a = Error(f(419))),
+                (a.stack = ''),
+                (a.digest = h),
+                Ul({ value: a, source: null, stack: null }),
+                (e = Ds(t, e, n)))
+            } else if (
+              (Kt || Ql(t, e, n, !1), (h = (n & t.childLanes) !== 0), Kt || h)
+            ) {
+              if (
+                ((h = Mt),
+                h !== null &&
+                  ((a = n & -n),
+                  (a = (a & 42) !== 0 ? 1 : rc(a)),
+                  (a = (a & (h.suspendedLanes | n)) !== 0 ? 0 : a),
+                  a !== 0 && a !== S.retryLane))
+              )
+                throw ((S.retryLane = a), Va(t, a), Te(h, t, a), N0)
+              ;(g.data === '$?' || ks(), (e = Ds(t, e, n)))
+            } else
+              g.data === '$?'
+                ? ((e.flags |= 192), (e.child = t.child), (e = null))
+                : ((t = S.treeContext),
+                  (Yt = Xe(g.nextSibling)),
+                  (se = e),
+                  (xt = !0),
+                  (oa = null),
+                  (Ve = !1),
+                  t !== null &&
+                    ((Me[je++] = $e),
+                    (Me[je++] = tn),
+                    (Me[je++] = fa),
+                    ($e = t.id),
+                    (tn = t.overflow),
+                    (fa = e)),
+                  (e = Os(e, a.children)),
+                  (e.flags |= 4096))
+            return e
+          }
+          return l
+            ? (Mn(),
+              (l = a.fallback),
+              (g = e.mode),
+              (S = t.child),
+              (B = S.sibling),
+              (a = _e(S, { mode: 'hidden', children: a.children })),
+              (a.subtreeFlags = S.subtreeFlags & 65011712),
+              B !== null
+                ? (l = _e(B, l))
+                : ((l = sa(l, g, n, null)), (l.flags |= 2)),
+              (l.return = e),
+              (a.return = e),
+              (a.sibling = l),
+              (e.child = a),
+              (a = l),
+              (l = e.child),
+              (g = t.child.memoizedState),
+              g === null
+                ? (g = ws(n))
+                : ((S = g.cachePool),
+                  S !== null
+                    ? ((B = It._currentValue),
+                      (S = S.parent !== B ? { parent: B, pool: B } : S))
+                    : (S = Do()),
+                  (g = { baseLanes: g.baseLanes | n, cachePool: S })),
+              (l.memoizedState = g),
+              (l.childLanes = Rs(t, h, n)),
+              (e.memoizedState = Ts),
+              a)
+            : (Cn(e),
+              (n = t.child),
+              (t = n.sibling),
+              (n = _e(n, { mode: 'visible', children: a.children })),
+              (n.return = e),
+              (n.sibling = null),
+              t !== null &&
+                ((h = e.deletions),
+                h === null
+                  ? ((e.deletions = [t]), (e.flags |= 16))
+                  : h.push(t)),
+              (e.child = n),
+              (e.memoizedState = null),
+              n)
+        }
+        function Os(t, e) {
+          return (
+            (e = Eu({ mode: 'visible', children: e }, t.mode)),
+            (e.return = t),
+            (t.child = e)
+          )
+        }
+        function Eu(t, e) {
+          return (
+            (t = Ee(22, t, null, e)),
+            (t.lanes = 0),
+            (t.stateNode = {
+              _visibility: 1,
+              _pendingMarkers: null,
+              _retryCache: null,
+              _transitions: null,
+            }),
+            t
+          )
+        }
+        function Ds(t, e, n) {
+          return (
+            $a(e, t.child, null, n),
+            (t = Os(e, e.pendingProps.children)),
+            (t.flags |= 2),
+            (e.memoizedState = null),
+            t
+          )
+        }
+        function I0(t, e, n) {
+          t.lanes |= e
+          var a = t.alternate
+          ;(a !== null && (a.lanes |= e), kc(t.return, e, n))
+        }
+        function Cs(t, e, n, a, l) {
+          var s = t.memoizedState
+          s === null
+            ? (t.memoizedState = {
+                isBackwards: e,
+                rendering: null,
+                renderingStartTime: 0,
+                last: a,
+                tail: n,
+                tailMode: l,
+              })
+            : ((s.isBackwards = e),
+              (s.rendering = null),
+              (s.renderingStartTime = 0),
+              (s.last = a),
+              (s.tail = n),
+              (s.tailMode = l))
+        }
+        function Z0(t, e, n) {
+          var a = e.pendingProps,
+            l = a.revealOrder,
+            s = a.tail
+          if ((_t(t, e, a.children, n), (a = Zt.current), (a & 2) !== 0))
+            ((a = (a & 1) | 2), (e.flags |= 128))
+          else {
+            if (t !== null && (t.flags & 128) !== 0)
+              t: for (t = e.child; t !== null; ) {
+                if (t.tag === 13) t.memoizedState !== null && I0(t, n, e)
+                else if (t.tag === 19) I0(t, n, e)
+                else if (t.child !== null) {
+                  ;((t.child.return = t), (t = t.child))
+                  continue
+                }
+                if (t === e) break t
+                for (; t.sibling === null; ) {
+                  if (t.return === null || t.return === e) break t
+                  t = t.return
+                }
+                ;((t.sibling.return = t.return), (t = t.sibling))
+              }
+            a &= 1
+          }
+          switch ((J(Zt, a), l)) {
+            case 'forwards':
+              for (n = e.child, l = null; n !== null; )
+                ((t = n.alternate),
+                  t !== null && mu(t) === null && (l = n),
+                  (n = n.sibling))
+              ;((n = l),
+                n === null
+                  ? ((l = e.child), (e.child = null))
+                  : ((l = n.sibling), (n.sibling = null)),
+                Cs(e, !1, l, n, s))
+              break
+            case 'backwards':
+              for (n = null, l = e.child, e.child = null; l !== null; ) {
+                if (((t = l.alternate), t !== null && mu(t) === null)) {
+                  e.child = l
+                  break
+                }
+                ;((t = l.sibling), (l.sibling = n), (n = l), (l = t))
+              }
+              Cs(e, !0, n, null, s)
+              break
+            case 'together':
+              Cs(e, !1, null, null, void 0)
+              break
+            default:
+              e.memoizedState = null
+          }
+          return e.child
+        }
+        function un(t, e, n) {
+          if (
+            (t !== null && (e.dependencies = t.dependencies),
+            (Un |= e.lanes),
+            (n & e.childLanes) === 0)
+          )
+            if (t !== null) {
+              if ((Ql(t, e, n, !1), (n & e.childLanes) === 0)) return null
+            } else return null
+          if (t !== null && e.child !== t.child) throw Error(f(153))
+          if (e.child !== null) {
+            for (
+              t = e.child, n = _e(t, t.pendingProps), e.child = n, n.return = e;
+              t.sibling !== null;
+            )
+              ((t = t.sibling),
+                (n = n.sibling = _e(t, t.pendingProps)),
+                (n.return = e))
+            n.sibling = null
+          }
+          return e.child
+        }
+        function Ms(t, e) {
+          return (t.lanes & e) !== 0
+            ? !0
+            : ((t = t.dependencies), !!(t !== null && $i(t)))
+        }
+        function om(t, e, n) {
+          switch (e.tag) {
+            case 3:
+              ;(Dt(e, e.stateNode.containerInfo),
+                Tn(e, It, t.memoizedState.cache),
+                Bl())
+              break
+            case 27:
+            case 5:
+              Ra(e)
+              break
+            case 4:
+              Dt(e, e.stateNode.containerInfo)
+              break
+            case 10:
+              Tn(e, e.type, e.memoizedProps.value)
+              break
+            case 13:
+              var a = e.memoizedState
+              if (a !== null)
+                return a.dehydrated !== null
+                  ? (Cn(e), (e.flags |= 128), null)
+                  : (n & e.child.childLanes) !== 0
+                    ? V0(t, e, n)
+                    : (Cn(e), (t = un(t, e, n)), t !== null ? t.sibling : null)
+              Cn(e)
+              break
+            case 19:
+              var l = (t.flags & 128) !== 0
+              if (
+                ((a = (n & e.childLanes) !== 0),
+                a || (Ql(t, e, n, !1), (a = (n & e.childLanes) !== 0)),
+                l)
+              ) {
+                if (a) return Z0(t, e, n)
+                e.flags |= 128
+              }
+              if (
+                ((l = e.memoizedState),
+                l !== null &&
+                  ((l.rendering = null),
+                  (l.tail = null),
+                  (l.lastEffect = null)),
+                J(Zt, Zt.current),
+                a)
+              )
+                break
+              return null
+            case 22:
+            case 23:
+              return ((e.lanes = 0), Y0(t, e, n))
+            case 24:
+              Tn(e, It, t.memoizedState.cache)
+          }
+          return un(t, e, n)
+        }
+        function q0(t, e, n) {
+          if (t !== null)
+            if (t.memoizedProps !== e.pendingProps) Kt = !0
+            else {
+              if (!Ms(t, n) && (e.flags & 128) === 0)
+                return ((Kt = !1), om(t, e, n))
+              Kt = (t.flags & 131072) !== 0
+            }
+          else
+            ((Kt = !1), xt && (e.flags & 1048576) !== 0 && po(e, _i, e.index))
+          switch (((e.lanes = 0), e.tag)) {
+            case 16:
+              t: {
+                t = e.pendingProps
+                var a = e.elementType,
+                  l = a._init
+                if (((a = l(a._payload)), (e.type = a), typeof a == 'function'))
+                  zc(a)
+                    ? ((t = va(a, t)), (e.tag = 1), (e = G0(null, e, a, t, n)))
+                    : ((e.tag = 0), (e = Ss(null, e, a, t, n)))
+                else {
+                  if (a != null) {
+                    if (((l = a.$$typeof), l === I)) {
+                      ;((e.tag = 11), (e = B0(null, e, a, t, n)))
+                      break t
+                    } else if (l === G) {
+                      ;((e.tag = 14), (e = U0(null, e, a, t, n)))
+                      break t
+                    }
+                  }
+                  throw ((e = ot(a) || a), Error(f(306, e, '')))
+                }
+              }
+              return e
+            case 0:
+              return Ss(t, e, e.type, e.pendingProps, n)
+            case 1:
+              return (
+                (a = e.type),
+                (l = va(a, e.pendingProps)),
+                G0(t, e, a, l, n)
+              )
+            case 3:
+              t: {
+                if ((Dt(e, e.stateNode.containerInfo), t === null))
+                  throw Error(f(387))
+                a = e.pendingProps
+                var s = e.memoizedState
+                ;((l = s.element), $c(t, e), Il(e, a, null, n))
+                var h = e.memoizedState
+                if (
+                  ((a = h.cache),
+                  Tn(e, It, a),
+                  a !== s.cache && Kc(e, [It], n, !0),
+                  Vl(),
+                  (a = h.element),
+                  s.isDehydrated)
+                )
+                  if (
+                    ((s = { element: a, isDehydrated: !1, cache: h.cache }),
+                    (e.updateQueue.baseState = s),
+                    (e.memoizedState = s),
+                    e.flags & 256)
+                  ) {
+                    e = X0(t, e, a, n)
+                    break t
+                  } else if (a !== l) {
+                    ;((l = De(Error(f(424)), e)), Ul(l), (e = X0(t, e, a, n)))
+                    break t
+                  } else {
+                    switch (((t = e.stateNode.containerInfo), t.nodeType)) {
+                      case 9:
+                        t = t.body
+                        break
+                      default:
+                        t = t.nodeName === 'HTML' ? t.ownerDocument.body : t
+                    }
+                    for (
+                      Yt = Xe(t.firstChild),
+                        se = e,
+                        xt = !0,
+                        oa = null,
+                        Ve = !0,
+                        n = S0(e, null, a, n),
+                        e.child = n;
+                      n;
+                    )
+                      ((n.flags = (n.flags & -3) | 4096), (n = n.sibling))
+                  }
+                else {
+                  if ((Bl(), a === l)) {
+                    e = un(t, e, n)
+                    break t
+                  }
+                  _t(t, e, a, n)
+                }
+                e = e.child
+              }
+              return e
+            case 26:
+              return (
+                yu(t, e),
+                t === null
+                  ? (n = Fd(e.type, null, e.pendingProps, null))
+                    ? (e.memoizedState = n)
+                    : xt ||
+                      ((n = e.type),
+                      (t = e.pendingProps),
+                      (a = Nu(ut.current).createElement(n)),
+                      (a[ne] = e),
+                      (a[re] = t),
+                      te(a, n, t),
+                      kt(a),
+                      (e.stateNode = a))
+                  : (e.memoizedState = Fd(
+                      e.type,
+                      t.memoizedProps,
+                      e.pendingProps,
+                      t.memoizedState,
+                    )),
+                null
+              )
+            case 27:
+              return (
+                Ra(e),
+                t === null &&
+                  xt &&
+                  ((a = e.stateNode = kd(e.type, e.pendingProps, ut.current)),
+                  (se = e),
+                  (Ve = !0),
+                  (l = Yt),
+                  zn(e.type) ? ((of = l), (Yt = Xe(a.firstChild))) : (Yt = l)),
+                _t(t, e, e.pendingProps.children, n),
+                yu(t, e),
+                t === null && (e.flags |= 4194304),
+                e.child
+              )
+            case 5:
+              return (
+                t === null &&
+                  xt &&
+                  ((l = a = Yt) &&
+                    ((a = zm(a, e.type, e.pendingProps, Ve)),
+                    a !== null
+                      ? ((e.stateNode = a),
+                        (se = e),
+                        (Yt = Xe(a.firstChild)),
+                        (Ve = !1),
+                        (l = !0))
+                      : (l = !1)),
+                  l || da(e)),
+                Ra(e),
+                (l = e.type),
+                (s = e.pendingProps),
+                (h = t !== null ? t.memoizedProps : null),
+                (a = s.children),
+                cf(l, s)
+                  ? (a = null)
+                  : h !== null && cf(l, h) && (e.flags |= 32),
+                e.memoizedState !== null &&
+                  ((l = is(t, e, am, null, null, n)), (oi._currentValue = l)),
+                yu(t, e),
+                _t(t, e, a, n),
+                e.child
+              )
+            case 6:
+              return (
+                t === null &&
+                  xt &&
+                  ((t = n = Yt) &&
+                    ((n = Gm(n, e.pendingProps, Ve)),
+                    n !== null
+                      ? ((e.stateNode = n), (se = e), (Yt = null), (t = !0))
+                      : (t = !1)),
+                  t || da(e)),
+                null
+              )
+            case 13:
+              return V0(t, e, n)
+            case 4:
+              return (
+                Dt(e, e.stateNode.containerInfo),
+                (a = e.pendingProps),
+                t === null ? (e.child = $a(e, null, a, n)) : _t(t, e, a, n),
+                e.child
+              )
+            case 11:
+              return B0(t, e, e.type, e.pendingProps, n)
+            case 7:
+              return (_t(t, e, e.pendingProps, n), e.child)
+            case 8:
+              return (_t(t, e, e.pendingProps.children, n), e.child)
+            case 12:
+              return (_t(t, e, e.pendingProps.children, n), e.child)
+            case 10:
+              return (
+                (a = e.pendingProps),
+                Tn(e, e.type, a.value),
+                _t(t, e, a.children, n),
+                e.child
+              )
+            case 9:
+              return (
+                (l = e.type._context),
+                (a = e.pendingProps.children),
+                ga(e),
+                (l = ae(l)),
+                (a = a(l)),
+                (e.flags |= 1),
+                _t(t, e, a, n),
+                e.child
+              )
+            case 14:
+              return U0(t, e, e.type, e.pendingProps, n)
+            case 15:
+              return Q0(t, e, e.type, e.pendingProps, n)
+            case 19:
+              return Z0(t, e, n)
+            case 31:
+              return (
+                (a = e.pendingProps),
+                (n = e.mode),
+                (a = { mode: a.mode, children: a.children }),
+                t === null
+                  ? ((n = Eu(a, n)),
+                    (n.ref = e.ref),
+                    (e.child = n),
+                    (n.return = e),
+                    (e = n))
+                  : ((n = _e(t.child, a)),
+                    (n.ref = e.ref),
+                    (e.child = n),
+                    (n.return = e),
+                    (e = n)),
+                e
+              )
+            case 22:
+              return Y0(t, e, n)
+            case 24:
+              return (
+                ga(e),
+                (a = ae(It)),
+                t === null
+                  ? ((l = Jc()),
+                    l === null &&
+                      ((l = Mt),
+                      (s = Wc()),
+                      (l.pooledCache = s),
+                      s.refCount++,
+                      s !== null && (l.pooledCacheLanes |= n),
+                      (l = s)),
+                    (e.memoizedState = { parent: a, cache: l }),
+                    _c(e),
+                    Tn(e, It, l))
+                  : ((t.lanes & n) !== 0 &&
+                      ($c(t, e), Il(e, null, null, n), Vl()),
+                    (l = t.memoizedState),
+                    (s = e.memoizedState),
+                    l.parent !== a
+                      ? ((l = { parent: a, cache: a }),
+                        (e.memoizedState = l),
+                        e.lanes === 0 &&
+                          (e.memoizedState = e.updateQueue.baseState = l),
+                        Tn(e, It, a))
+                      : ((a = s.cache),
+                        Tn(e, It, a),
+                        a !== l.cache && Kc(e, [It], n, !0))),
+                _t(t, e, e.pendingProps.children, n),
+                e.child
+              )
+            case 29:
+              throw e.pendingProps
+          }
+          throw Error(f(156, e.tag))
+        }
+        function cn(t) {
+          t.flags |= 4
+        }
+        function k0(t, e) {
+          if (e.type !== 'stylesheet' || (e.state.loading & 4) !== 0)
+            t.flags &= -16777217
+          else if (((t.flags |= 16777216), !t1(e))) {
+            if (
+              ((e = He.current),
+              e !== null &&
+                ((Et & 4194048) === Et
+                  ? Ie !== null
+                  : ((Et & 62914560) !== Et && (Et & 536870912) === 0) ||
+                    e !== Ie))
+            )
+              throw ((Gl = Pc), Co)
+            t.flags |= 8192
+          }
+        }
+        function bu(t, e) {
+          ;(e !== null && (t.flags |= 4),
+            t.flags & 16384 &&
+              ((e = t.tag !== 22 ? Sr() : 536870912),
+              (t.lanes |= e),
+              (al |= e)))
+        }
+        function Jl(t, e) {
+          if (!xt)
+            switch (t.tailMode) {
+              case 'hidden':
+                e = t.tail
+                for (var n = null; e !== null; )
+                  (e.alternate !== null && (n = e), (e = e.sibling))
+                n === null ? (t.tail = null) : (n.sibling = null)
+                break
+              case 'collapsed':
+                n = t.tail
+                for (var a = null; n !== null; )
+                  (n.alternate !== null && (a = n), (n = n.sibling))
+                a === null
+                  ? e || t.tail === null
+                    ? (t.tail = null)
+                    : (t.tail.sibling = null)
+                  : (a.sibling = null)
+            }
+        }
+        function Qt(t) {
+          var e = t.alternate !== null && t.alternate.child === t.child,
+            n = 0,
+            a = 0
+          if (e)
+            for (var l = t.child; l !== null; )
+              ((n |= l.lanes | l.childLanes),
+                (a |= l.subtreeFlags & 65011712),
+                (a |= l.flags & 65011712),
+                (l.return = t),
+                (l = l.sibling))
+          else
+            for (l = t.child; l !== null; )
+              ((n |= l.lanes | l.childLanes),
+                (a |= l.subtreeFlags),
+                (a |= l.flags),
+                (l.return = t),
+                (l = l.sibling))
+          return ((t.subtreeFlags |= a), (t.childLanes = n), e)
+        }
+        function dm(t, e, n) {
+          var a = e.pendingProps
+          switch ((Ic(e), e.tag)) {
+            case 31:
+            case 16:
+            case 15:
+            case 0:
+            case 11:
+            case 7:
+            case 8:
+            case 12:
+            case 9:
+            case 14:
+              return (Qt(e), null)
+            case 1:
+              return (Qt(e), null)
+            case 3:
+              return (
+                (n = e.stateNode),
+                (a = null),
+                t !== null && (a = t.memoizedState.cache),
+                e.memoizedState.cache !== a && (e.flags |= 2048),
+                nn(It),
+                Le(),
+                n.pendingContext &&
+                  ((n.context = n.pendingContext), (n.pendingContext = null)),
+                (t === null || t.child === null) &&
+                  (Nl(e)
+                    ? cn(e)
+                    : t === null ||
+                      (t.memoizedState.isDehydrated && (e.flags & 256) === 0) ||
+                      ((e.flags |= 1024), To())),
+                Qt(e),
+                null
+              )
+            case 26:
+              return (
+                (n = e.memoizedState),
+                t === null
+                  ? (cn(e),
+                    n !== null
+                      ? (Qt(e), k0(e, n))
+                      : (Qt(e), (e.flags &= -16777217)))
+                  : n
+                    ? n !== t.memoizedState
+                      ? (cn(e), Qt(e), k0(e, n))
+                      : (Qt(e), (e.flags &= -16777217))
+                    : (t.memoizedProps !== a && cn(e),
+                      Qt(e),
+                      (e.flags &= -16777217)),
+                null
+              )
+            case 27:
+              ;(ea(e), (n = ut.current))
+              var l = e.type
+              if (t !== null && e.stateNode != null)
+                t.memoizedProps !== a && cn(e)
+              else {
+                if (!a) {
+                  if (e.stateNode === null) throw Error(f(166))
+                  return (Qt(e), null)
+                }
+                ;((t = it.current),
+                  Nl(e) ? xo(e) : ((t = kd(l, a, n)), (e.stateNode = t), cn(e)))
+              }
+              return (Qt(e), null)
+            case 5:
+              if ((ea(e), (n = e.type), t !== null && e.stateNode != null))
+                t.memoizedProps !== a && cn(e)
+              else {
+                if (!a) {
+                  if (e.stateNode === null) throw Error(f(166))
+                  return (Qt(e), null)
+                }
+                if (((t = it.current), Nl(e))) xo(e)
+                else {
+                  switch (((l = Nu(ut.current)), t)) {
+                    case 1:
+                      t = l.createElementNS('http://www.w3.org/2000/svg', n)
+                      break
+                    case 2:
+                      t = l.createElementNS(
+                        'http://www.w3.org/1998/Math/MathML',
+                        n,
+                      )
+                      break
+                    default:
+                      switch (n) {
+                        case 'svg':
+                          t = l.createElementNS('http://www.w3.org/2000/svg', n)
+                          break
+                        case 'math':
+                          t = l.createElementNS(
+                            'http://www.w3.org/1998/Math/MathML',
+                            n,
+                          )
+                          break
+                        case 'script':
+                          ;((t = l.createElement('div')),
+                            (t.innerHTML = '<script><\/script>'),
+                            (t = t.removeChild(t.firstChild)))
+                          break
+                        case 'select':
+                          ;((t =
+                            typeof a.is == 'string'
+                              ? l.createElement('select', { is: a.is })
+                              : l.createElement('select')),
+                            a.multiple
+                              ? (t.multiple = !0)
+                              : a.size && (t.size = a.size))
+                          break
+                        default:
+                          t =
+                            typeof a.is == 'string'
+                              ? l.createElement(n, { is: a.is })
+                              : l.createElement(n)
+                      }
+                  }
+                  ;((t[ne] = e), (t[re] = a))
+                  t: for (l = e.child; l !== null; ) {
+                    if (l.tag === 5 || l.tag === 6) t.appendChild(l.stateNode)
+                    else if (l.tag !== 4 && l.tag !== 27 && l.child !== null) {
+                      ;((l.child.return = l), (l = l.child))
+                      continue
+                    }
+                    if (l === e) break t
+                    for (; l.sibling === null; ) {
+                      if (l.return === null || l.return === e) break t
+                      l = l.return
+                    }
+                    ;((l.sibling.return = l.return), (l = l.sibling))
+                  }
+                  e.stateNode = t
+                  t: switch ((te(t, n, a), n)) {
+                    case 'button':
+                    case 'input':
+                    case 'select':
+                    case 'textarea':
+                      t = !!a.autoFocus
+                      break t
+                    case 'img':
+                      t = !0
+                      break t
+                    default:
+                      t = !1
+                  }
+                  t && cn(e)
+                }
+              }
+              return (Qt(e), (e.flags &= -16777217), null)
+            case 6:
+              if (t && e.stateNode != null) t.memoizedProps !== a && cn(e)
+              else {
+                if (typeof a != 'string' && e.stateNode === null)
+                  throw Error(f(166))
+                if (((t = ut.current), Nl(e))) {
+                  if (
+                    ((t = e.stateNode),
+                    (n = e.memoizedProps),
+                    (a = null),
+                    (l = se),
+                    l !== null)
+                  )
+                    switch (l.tag) {
+                      case 27:
+                      case 5:
+                        a = l.memoizedProps
+                    }
+                  ;((t[ne] = e),
+                    (t = !!(
+                      t.nodeValue === n ||
+                      (a !== null && a.suppressHydrationWarning === !0) ||
+                      zd(t.nodeValue, n)
+                    )),
+                    t || da(e))
+                } else
+                  ((t = Nu(t).createTextNode(a)),
+                    (t[ne] = e),
+                    (e.stateNode = t))
+              }
+              return (Qt(e), null)
+            case 13:
+              if (
+                ((a = e.memoizedState),
+                t === null ||
+                  (t.memoizedState !== null &&
+                    t.memoizedState.dehydrated !== null))
+              ) {
+                if (((l = Nl(e)), a !== null && a.dehydrated !== null)) {
+                  if (t === null) {
+                    if (!l) throw Error(f(318))
+                    if (
+                      ((l = e.memoizedState),
+                      (l = l !== null ? l.dehydrated : null),
+                      !l)
+                    )
+                      throw Error(f(317))
+                    l[ne] = e
+                  } else
+                    (Bl(),
+                      (e.flags & 128) === 0 && (e.memoizedState = null),
+                      (e.flags |= 4))
+                  ;(Qt(e), (l = !1))
+                } else
+                  ((l = To()),
+                    t !== null &&
+                      t.memoizedState !== null &&
+                      (t.memoizedState.hydrationErrors = l),
+                    (l = !0))
+                if (!l) return e.flags & 256 ? (ln(e), e) : (ln(e), null)
+              }
+              if ((ln(e), (e.flags & 128) !== 0)) return ((e.lanes = n), e)
+              if (
+                ((n = a !== null),
+                (t = t !== null && t.memoizedState !== null),
+                n)
+              ) {
+                ;((a = e.child),
+                  (l = null),
+                  a.alternate !== null &&
+                    a.alternate.memoizedState !== null &&
+                    a.alternate.memoizedState.cachePool !== null &&
+                    (l = a.alternate.memoizedState.cachePool.pool))
+                var s = null
+                ;(a.memoizedState !== null &&
+                  a.memoizedState.cachePool !== null &&
+                  (s = a.memoizedState.cachePool.pool),
+                  s !== l && (a.flags |= 2048))
+              }
+              return (
+                n !== t && n && (e.child.flags |= 8192),
+                bu(e, e.updateQueue),
+                Qt(e),
+                null
+              )
+            case 4:
+              return (
+                Le(),
+                t === null && ef(e.stateNode.containerInfo),
+                Qt(e),
+                null
+              )
+            case 10:
+              return (nn(e.type), Qt(e), null)
+            case 19:
+              if ((P(Zt), (l = e.memoizedState), l === null))
+                return (Qt(e), null)
+              if (((a = (e.flags & 128) !== 0), (s = l.rendering), s === null))
+                if (a) Jl(l, !1)
+                else {
+                  if (Lt !== 0 || (t !== null && (t.flags & 128) !== 0))
+                    for (t = e.child; t !== null; ) {
+                      if (((s = mu(t)), s !== null)) {
+                        for (
+                          e.flags |= 128,
+                            Jl(l, !1),
+                            t = s.updateQueue,
+                            e.updateQueue = t,
+                            bu(e, t),
+                            e.subtreeFlags = 0,
+                            t = n,
+                            n = e.child;
+                          n !== null;
+                        )
+                          (bo(n, t), (n = n.sibling))
+                        return (J(Zt, (Zt.current & 1) | 2), e.child)
+                      }
+                      t = t.sibling
+                    }
+                  l.tail !== null &&
+                    ce() > Su &&
+                    ((e.flags |= 128), (a = !0), Jl(l, !1), (e.lanes = 4194304))
+                }
+              else {
+                if (!a)
+                  if (((t = mu(s)), t !== null)) {
+                    if (
+                      ((e.flags |= 128),
+                      (a = !0),
+                      (t = t.updateQueue),
+                      (e.updateQueue = t),
+                      bu(e, t),
+                      Jl(l, !0),
+                      l.tail === null &&
+                        l.tailMode === 'hidden' &&
+                        !s.alternate &&
+                        !xt)
+                    )
+                      return (Qt(e), null)
+                  } else
+                    2 * ce() - l.renderingStartTime > Su &&
+                      n !== 536870912 &&
+                      ((e.flags |= 128),
+                      (a = !0),
+                      Jl(l, !1),
+                      (e.lanes = 4194304))
+                l.isBackwards
+                  ? ((s.sibling = e.child), (e.child = s))
+                  : ((t = l.last),
+                    t !== null ? (t.sibling = s) : (e.child = s),
+                    (l.last = s))
+              }
+              return l.tail !== null
+                ? ((e = l.tail),
+                  (l.rendering = e),
+                  (l.tail = e.sibling),
+                  (l.renderingStartTime = ce()),
+                  (e.sibling = null),
+                  (t = Zt.current),
+                  J(Zt, a ? (t & 1) | 2 : t & 1),
+                  e)
+                : (Qt(e), null)
+            case 22:
+            case 23:
+              return (
+                ln(e),
+                as(),
+                (a = e.memoizedState !== null),
+                t !== null
+                  ? (t.memoizedState !== null) !== a && (e.flags |= 8192)
+                  : a && (e.flags |= 8192),
+                a
+                  ? (n & 536870912) !== 0 &&
+                    (e.flags & 128) === 0 &&
+                    (Qt(e), e.subtreeFlags & 6 && (e.flags |= 8192))
+                  : Qt(e),
+                (n = e.updateQueue),
+                n !== null && bu(e, n.retryQueue),
+                (n = null),
+                t !== null &&
+                  t.memoizedState !== null &&
+                  t.memoizedState.cachePool !== null &&
+                  (n = t.memoizedState.cachePool.pool),
+                (a = null),
+                e.memoizedState !== null &&
+                  e.memoizedState.cachePool !== null &&
+                  (a = e.memoizedState.cachePool.pool),
+                a !== n && (e.flags |= 2048),
+                t !== null && P(ma),
+                null
+              )
+            case 24:
+              return (
+                (n = null),
+                t !== null && (n = t.memoizedState.cache),
+                e.memoizedState.cache !== n && (e.flags |= 2048),
+                nn(It),
+                Qt(e),
+                null
+              )
+            case 25:
+              return null
+            case 30:
+              return null
+          }
+          throw Error(f(156, e.tag))
+        }
+        function hm(t, e) {
+          switch ((Ic(e), e.tag)) {
+            case 1:
+              return (
+                (t = e.flags),
+                t & 65536 ? ((e.flags = (t & -65537) | 128), e) : null
+              )
+            case 3:
+              return (
+                nn(It),
+                Le(),
+                (t = e.flags),
+                (t & 65536) !== 0 && (t & 128) === 0
+                  ? ((e.flags = (t & -65537) | 128), e)
+                  : null
+              )
+            case 26:
+            case 27:
+            case 5:
+              return (ea(e), null)
+            case 13:
+              if (
+                (ln(e),
+                (t = e.memoizedState),
+                t !== null && t.dehydrated !== null)
+              ) {
+                if (e.alternate === null) throw Error(f(340))
+                Bl()
+              }
+              return (
+                (t = e.flags),
+                t & 65536 ? ((e.flags = (t & -65537) | 128), e) : null
+              )
+            case 19:
+              return (P(Zt), null)
+            case 4:
+              return (Le(), null)
+            case 10:
+              return (nn(e.type), null)
+            case 22:
+            case 23:
+              return (
+                ln(e),
+                as(),
+                t !== null && P(ma),
+                (t = e.flags),
+                t & 65536 ? ((e.flags = (t & -65537) | 128), e) : null
+              )
+            case 24:
+              return (nn(It), null)
+            case 25:
+              return null
+            default:
+              return null
+          }
+        }
+        function K0(t, e) {
+          switch ((Ic(e), e.tag)) {
+            case 3:
+              ;(nn(It), Le())
+              break
+            case 26:
+            case 27:
+            case 5:
+              ea(e)
+              break
+            case 4:
+              Le()
+              break
+            case 13:
+              ln(e)
+              break
+            case 19:
+              P(Zt)
+              break
+            case 10:
+              nn(e.type)
+              break
+            case 22:
+            case 23:
+              ;(ln(e), as(), t !== null && P(ma))
+              break
+            case 24:
+              nn(It)
+          }
+        }
+        function Pl(t, e) {
+          try {
+            var n = e.updateQueue,
+              a = n !== null ? n.lastEffect : null
+            if (a !== null) {
+              var l = a.next
+              n = l
+              do {
+                if ((n.tag & t) === t) {
+                  a = void 0
+                  var s = n.create,
+                    h = n.inst
+                  ;((a = s()), (h.destroy = a))
+                }
+                n = n.next
+              } while (n !== l)
+            }
+          } catch (g) {
+            Ct(e, e.return, g)
+          }
+        }
+        function jn(t, e, n) {
+          try {
+            var a = e.updateQueue,
+              l = a !== null ? a.lastEffect : null
+            if (l !== null) {
+              var s = l.next
+              a = s
+              do {
+                if ((a.tag & t) === t) {
+                  var h = a.inst,
+                    g = h.destroy
+                  if (g !== void 0) {
+                    ;((h.destroy = void 0), (l = e))
+                    var S = n,
+                      B = g
+                    try {
+                      B()
+                    } catch (X) {
+                      Ct(l, S, X)
+                    }
+                  }
+                }
+                a = a.next
+              } while (a !== s)
+            }
+          } catch (X) {
+            Ct(e, e.return, X)
+          }
+        }
+        function W0(t) {
+          var e = t.updateQueue
+          if (e !== null) {
+            var n = t.stateNode
+            try {
+              Uo(e, n)
+            } catch (a) {
+              Ct(t, t.return, a)
+            }
+          }
+        }
+        function F0(t, e, n) {
+          ;((n.props = va(t.type, t.memoizedProps)),
+            (n.state = t.memoizedState))
+          try {
+            n.componentWillUnmount()
+          } catch (a) {
+            Ct(t, e, a)
+          }
+        }
+        function _l(t, e) {
+          try {
+            var n = t.ref
+            if (n !== null) {
+              switch (t.tag) {
+                case 26:
+                case 27:
+                case 5:
+                  var a = t.stateNode
+                  break
+                case 30:
+                  a = t.stateNode
+                  break
+                default:
+                  a = t.stateNode
+              }
+              typeof n == 'function' ? (t.refCleanup = n(a)) : (n.current = a)
+            }
+          } catch (l) {
+            Ct(t, e, l)
+          }
+        }
+        function Ze(t, e) {
+          var n = t.ref,
+            a = t.refCleanup
+          if (n !== null)
+            if (typeof a == 'function')
+              try {
+                a()
+              } catch (l) {
+                Ct(t, e, l)
+              } finally {
+                ;((t.refCleanup = null),
+                  (t = t.alternate),
+                  t != null && (t.refCleanup = null))
+              }
+            else if (typeof n == 'function')
+              try {
+                n(null)
+              } catch (l) {
+                Ct(t, e, l)
+              }
+            else n.current = null
+        }
+        function J0(t) {
+          var e = t.type,
+            n = t.memoizedProps,
+            a = t.stateNode
+          try {
+            t: switch (e) {
+              case 'button':
+              case 'input':
+              case 'select':
+              case 'textarea':
+                n.autoFocus && a.focus()
+                break t
+              case 'img':
+                n.src ? (a.src = n.src) : n.srcSet && (a.srcset = n.srcSet)
+            }
+          } catch (l) {
+            Ct(t, t.return, l)
+          }
+        }
+        function js(t, e, n) {
+          try {
+            var a = t.stateNode
+            ;(Bm(a, t.type, n, e), (a[re] = e))
+          } catch (l) {
+            Ct(t, t.return, l)
+          }
+        }
+        function P0(t) {
+          return (
+            t.tag === 5 ||
+            t.tag === 3 ||
+            t.tag === 26 ||
+            (t.tag === 27 && zn(t.type)) ||
+            t.tag === 4
+          )
+        }
+        function Hs(t) {
+          t: for (;;) {
+            for (; t.sibling === null; ) {
+              if (t.return === null || P0(t.return)) return null
+              t = t.return
+            }
+            for (
+              t.sibling.return = t.return, t = t.sibling;
+              t.tag !== 5 && t.tag !== 6 && t.tag !== 18;
+            ) {
+              if (
+                (t.tag === 27 && zn(t.type)) ||
+                t.flags & 2 ||
+                t.child === null ||
+                t.tag === 4
+              )
+                continue t
+              ;((t.child.return = t), (t = t.child))
+            }
+            if (!(t.flags & 2)) return t.stateNode
+          }
+        }
+        function Ns(t, e, n) {
+          var a = t.tag
+          if (a === 5 || a === 6)
+            ((t = t.stateNode),
+              e
+                ? (n.nodeType === 9
+                    ? n.body
+                    : n.nodeName === 'HTML'
+                      ? n.ownerDocument.body
+                      : n
+                  ).insertBefore(t, e)
+                : ((e =
+                    n.nodeType === 9
+                      ? n.body
+                      : n.nodeName === 'HTML'
+                        ? n.ownerDocument.body
+                        : n),
+                  e.appendChild(t),
+                  (n = n._reactRootContainer),
+                  n != null || e.onclick !== null || (e.onclick = Hu)))
+          else if (
+            a !== 4 &&
+            (a === 27 && zn(t.type) && ((n = t.stateNode), (e = null)),
+            (t = t.child),
+            t !== null)
+          )
+            for (Ns(t, e, n), t = t.sibling; t !== null; )
+              (Ns(t, e, n), (t = t.sibling))
+        }
+        function pu(t, e, n) {
+          var a = t.tag
+          if (a === 5 || a === 6)
+            ((t = t.stateNode), e ? n.insertBefore(t, e) : n.appendChild(t))
+          else if (
+            a !== 4 &&
+            (a === 27 && zn(t.type) && (n = t.stateNode),
+            (t = t.child),
+            t !== null)
+          )
+            for (pu(t, e, n), t = t.sibling; t !== null; )
+              (pu(t, e, n), (t = t.sibling))
+        }
+        function _0(t) {
+          var e = t.stateNode,
+            n = t.memoizedProps
+          try {
+            for (var a = t.type, l = e.attributes; l.length; )
+              e.removeAttributeNode(l[0])
+            ;(te(e, a, n), (e[ne] = t), (e[re] = n))
+          } catch (s) {
+            Ct(t, t.return, s)
+          }
+        }
+        var sn = !1,
+          Gt = !1,
+          Bs = !1,
+          $0 = typeof WeakSet == 'function' ? WeakSet : Set,
+          Wt = null
+        function gm(t, e) {
+          if (((t = t.containerInfo), (lf = zu), (t = fo(t)), Hc(t))) {
+            if ('selectionStart' in t)
+              var n = { start: t.selectionStart, end: t.selectionEnd }
+            else
+              t: {
+                n = ((n = t.ownerDocument) && n.defaultView) || window
+                var a = n.getSelection && n.getSelection()
+                if (a && a.rangeCount !== 0) {
+                  n = a.anchorNode
+                  var l = a.anchorOffset,
+                    s = a.focusNode
+                  a = a.focusOffset
+                  try {
+                    ;(n.nodeType, s.nodeType)
+                  } catch {
+                    n = null
+                    break t
+                  }
+                  var h = 0,
+                    g = -1,
+                    S = -1,
+                    B = 0,
+                    X = 0,
+                    k = t,
+                    Q = null
+                  e: for (;;) {
+                    for (
+                      var Y;
+                      k !== n || (l !== 0 && k.nodeType !== 3) || (g = h + l),
+                        k !== s || (a !== 0 && k.nodeType !== 3) || (S = h + a),
+                        k.nodeType === 3 && (h += k.nodeValue.length),
+                        (Y = k.firstChild) !== null;
+                    )
+                      ((Q = k), (k = Y))
+                    for (;;) {
+                      if (k === t) break e
+                      if (
+                        (Q === n && ++B === l && (g = h),
+                        Q === s && ++X === a && (S = h),
+                        (Y = k.nextSibling) !== null)
+                      )
+                        break
+                      ;((k = Q), (Q = k.parentNode))
+                    }
+                    k = Y
+                  }
+                  n = g === -1 || S === -1 ? null : { start: g, end: S }
+                } else n = null
+              }
+            n = n || { start: 0, end: 0 }
+          } else n = null
+          for (
+            uf = { focusedElem: t, selectionRange: n }, zu = !1, Wt = e;
+            Wt !== null;
+          )
+            if (
+              ((e = Wt),
+              (t = e.child),
+              (e.subtreeFlags & 1024) !== 0 && t !== null)
+            )
+              ((t.return = e), (Wt = t))
+            else
+              for (; Wt !== null; ) {
+                switch (((e = Wt), (s = e.alternate), (t = e.flags), e.tag)) {
+                  case 0:
+                    break
+                  case 11:
+                  case 15:
+                    break
+                  case 1:
+                    if ((t & 1024) !== 0 && s !== null) {
+                      ;((t = void 0),
+                        (n = e),
+                        (l = s.memoizedProps),
+                        (s = s.memoizedState),
+                        (a = n.stateNode))
+                      try {
+                        var rt = va(n.type, l, n.elementType === n.type)
+                        ;((t = a.getSnapshotBeforeUpdate(rt, s)),
+                          (a.__reactInternalSnapshotBeforeUpdate = t))
+                      } catch (st) {
+                        Ct(n, n.return, st)
+                      }
+                    }
+                    break
+                  case 3:
+                    if ((t & 1024) !== 0) {
+                      if (
+                        ((t = e.stateNode.containerInfo),
+                        (n = t.nodeType),
+                        n === 9)
+                      )
+                        ff(t)
+                      else if (n === 1)
+                        switch (t.nodeName) {
+                          case 'HEAD':
+                          case 'HTML':
+                          case 'BODY':
+                            ff(t)
+                            break
+                          default:
+                            t.textContent = ''
+                        }
+                    }
+                    break
+                  case 5:
+                  case 26:
+                  case 27:
+                  case 6:
+                  case 4:
+                  case 17:
+                    break
+                  default:
+                    if ((t & 1024) !== 0) throw Error(f(163))
+                }
+                if (((t = e.sibling), t !== null)) {
+                  ;((t.return = e.return), (Wt = t))
+                  break
+                }
+                Wt = e.return
+              }
+        }
+        function td(t, e, n) {
+          var a = n.flags
+          switch (n.tag) {
+            case 0:
+            case 11:
+            case 15:
+              ;(Hn(t, n), a & 4 && Pl(5, n))
+              break
+            case 1:
+              if ((Hn(t, n), a & 4))
+                if (((t = n.stateNode), e === null))
+                  try {
+                    t.componentDidMount()
+                  } catch (h) {
+                    Ct(n, n.return, h)
+                  }
+                else {
+                  var l = va(n.type, e.memoizedProps)
+                  e = e.memoizedState
+                  try {
+                    t.componentDidUpdate(
+                      l,
+                      e,
+                      t.__reactInternalSnapshotBeforeUpdate,
+                    )
+                  } catch (h) {
+                    Ct(n, n.return, h)
+                  }
+                }
+              ;(a & 64 && W0(n), a & 512 && _l(n, n.return))
+              break
+            case 3:
+              if ((Hn(t, n), a & 64 && ((t = n.updateQueue), t !== null))) {
+                if (((e = null), n.child !== null))
+                  switch (n.child.tag) {
+                    case 27:
+                    case 5:
+                      e = n.child.stateNode
+                      break
+                    case 1:
+                      e = n.child.stateNode
+                  }
+                try {
+                  Uo(t, e)
+                } catch (h) {
+                  Ct(n, n.return, h)
+                }
+              }
+              break
+            case 27:
+              e === null && a & 4 && _0(n)
+            case 26:
+            case 5:
+              ;(Hn(t, n),
+                e === null && a & 4 && J0(n),
+                a & 512 && _l(n, n.return))
+              break
+            case 12:
+              Hn(t, n)
+              break
+            case 13:
+              ;(Hn(t, n),
+                a & 4 && ad(t, n),
+                a & 64 &&
+                  ((t = n.memoizedState),
+                  t !== null &&
+                    ((t = t.dehydrated),
+                    t !== null && ((n = Sm.bind(null, n)), Xm(t, n)))))
+              break
+            case 22:
+              if (((a = n.memoizedState !== null || sn), !a)) {
+                ;((e = (e !== null && e.memoizedState !== null) || Gt),
+                  (l = sn))
+                var s = Gt
+                ;((sn = a),
+                  (Gt = e) && !s
+                    ? Nn(t, n, (n.subtreeFlags & 8772) !== 0)
+                    : Hn(t, n),
+                  (sn = l),
+                  (Gt = s))
+              }
+              break
+            case 30:
+              break
+            default:
+              Hn(t, n)
+          }
+        }
+        function ed(t) {
+          var e = t.alternate
+          ;(e !== null && ((t.alternate = null), ed(e)),
+            (t.child = null),
+            (t.deletions = null),
+            (t.sibling = null),
+            t.tag === 5 && ((e = t.stateNode), e !== null && hc(e)),
+            (t.stateNode = null),
+            (t.return = null),
+            (t.dependencies = null),
+            (t.memoizedProps = null),
+            (t.memoizedState = null),
+            (t.pendingProps = null),
+            (t.stateNode = null),
+            (t.updateQueue = null))
+        }
+        var Bt = null,
+          he = !1
+        function fn(t, e, n) {
+          for (n = n.child; n !== null; ) (nd(t, e, n), (n = n.sibling))
+        }
+        function nd(t, e, n) {
+          if (Ae && typeof Ae.onCommitFiberUnmount == 'function')
+            try {
+              Ae.onCommitFiberUnmount(El, n)
+            } catch {}
+          switch (n.tag) {
+            case 26:
+              ;(Gt || Ze(n, e),
+                fn(t, e, n),
+                n.memoizedState
+                  ? n.memoizedState.count--
+                  : n.stateNode &&
+                    ((n = n.stateNode), n.parentNode.removeChild(n)))
+              break
+            case 27:
+              Gt || Ze(n, e)
+              var a = Bt,
+                l = he
+              ;(zn(n.type) && ((Bt = n.stateNode), (he = !1)),
+                fn(t, e, n),
+                ci(n.stateNode),
+                (Bt = a),
+                (he = l))
+              break
+            case 5:
+              Gt || Ze(n, e)
+            case 6:
+              if (
+                ((a = Bt),
+                (l = he),
+                (Bt = null),
+                fn(t, e, n),
+                (Bt = a),
+                (he = l),
+                Bt !== null)
+              )
+                if (he)
+                  try {
+                    ;(Bt.nodeType === 9
+                      ? Bt.body
+                      : Bt.nodeName === 'HTML'
+                        ? Bt.ownerDocument.body
+                        : Bt
+                    ).removeChild(n.stateNode)
+                  } catch (s) {
+                    Ct(n, e, s)
+                  }
+                else
+                  try {
+                    Bt.removeChild(n.stateNode)
+                  } catch (s) {
+                    Ct(n, e, s)
+                  }
+              break
+            case 18:
+              Bt !== null &&
+                (he
+                  ? ((t = Bt),
+                    Zd(
+                      t.nodeType === 9
+                        ? t.body
+                        : t.nodeName === 'HTML'
+                          ? t.ownerDocument.body
+                          : t,
+                      n.stateNode,
+                    ),
+                    mi(t))
+                  : Zd(Bt, n.stateNode))
+              break
+            case 4:
+              ;((a = Bt),
+                (l = he),
+                (Bt = n.stateNode.containerInfo),
+                (he = !0),
+                fn(t, e, n),
+                (Bt = a),
+                (he = l))
+              break
+            case 0:
+            case 11:
+            case 14:
+            case 15:
+              ;(Gt || jn(2, n, e), Gt || jn(4, n, e), fn(t, e, n))
+              break
+            case 1:
+              ;(Gt ||
+                (Ze(n, e),
+                (a = n.stateNode),
+                typeof a.componentWillUnmount == 'function' && F0(n, e, a)),
+                fn(t, e, n))
+              break
+            case 21:
+              fn(t, e, n)
+              break
+            case 22:
+              ;((Gt = (a = Gt) || n.memoizedState !== null),
+                fn(t, e, n),
+                (Gt = a))
+              break
+            default:
+              fn(t, e, n)
+          }
+        }
+        function ad(t, e) {
+          if (
+            e.memoizedState === null &&
+            ((t = e.alternate),
+            t !== null &&
+              ((t = t.memoizedState),
+              t !== null && ((t = t.dehydrated), t !== null)))
+          )
+            try {
+              mi(t)
+            } catch (n) {
+              Ct(e, e.return, n)
+            }
+        }
+        function mm(t) {
+          switch (t.tag) {
+            case 13:
+            case 19:
+              var e = t.stateNode
+              return (e === null && (e = t.stateNode = new $0()), e)
+            case 22:
+              return (
+                (t = t.stateNode),
+                (e = t._retryCache),
+                e === null && (e = t._retryCache = new $0()),
+                e
+              )
+            default:
+              throw Error(f(435, t.tag))
+          }
+        }
+        function Us(t, e) {
+          var n = mm(t)
+          e.forEach(function (a) {
+            var l = Tm.bind(null, t, a)
+            n.has(a) || (n.add(a), a.then(l, l))
+          })
+        }
+        function be(t, e) {
+          var n = e.deletions
+          if (n !== null)
+            for (var a = 0; a < n.length; a++) {
+              var l = n[a],
+                s = t,
+                h = e,
+                g = h
+              t: for (; g !== null; ) {
+                switch (g.tag) {
+                  case 27:
+                    if (zn(g.type)) {
+                      ;((Bt = g.stateNode), (he = !1))
+                      break t
+                    }
+                    break
+                  case 5:
+                    ;((Bt = g.stateNode), (he = !1))
+                    break t
+                  case 3:
+                  case 4:
+                    ;((Bt = g.stateNode.containerInfo), (he = !0))
+                    break t
+                }
+                g = g.return
+              }
+              if (Bt === null) throw Error(f(160))
+              ;(nd(s, h, l),
+                (Bt = null),
+                (he = !1),
+                (s = l.alternate),
+                s !== null && (s.return = null),
+                (l.return = null))
+            }
+          if (e.subtreeFlags & 13878)
+            for (e = e.child; e !== null; ) (ld(e, t), (e = e.sibling))
+        }
+        var Ge = null
+        function ld(t, e) {
+          var n = t.alternate,
+            a = t.flags
+          switch (t.tag) {
+            case 0:
+            case 11:
+            case 14:
+            case 15:
+              ;(be(e, t),
+                pe(t),
+                a & 4 && (jn(3, t, t.return), Pl(3, t), jn(5, t, t.return)))
+              break
+            case 1:
+              ;(be(e, t),
+                pe(t),
+                a & 512 && (Gt || n === null || Ze(n, n.return)),
+                a & 64 &&
+                  sn &&
+                  ((t = t.updateQueue),
+                  t !== null &&
+                    ((a = t.callbacks),
+                    a !== null &&
+                      ((n = t.shared.hiddenCallbacks),
+                      (t.shared.hiddenCallbacks =
+                        n === null ? a : n.concat(a))))))
+              break
+            case 26:
+              var l = Ge
+              if (
+                (be(e, t),
+                pe(t),
+                a & 512 && (Gt || n === null || Ze(n, n.return)),
+                a & 4)
+              ) {
+                var s = n !== null ? n.memoizedState : null
+                if (((a = t.memoizedState), n === null))
+                  if (a === null)
+                    if (t.stateNode === null) {
+                      t: {
+                        ;((a = t.type),
+                          (n = t.memoizedProps),
+                          (l = l.ownerDocument || l))
+                        e: switch (a) {
+                          case 'title':
+                            ;((s = l.getElementsByTagName('title')[0]),
+                              (!s ||
+                                s[xl] ||
+                                s[ne] ||
+                                s.namespaceURI ===
+                                  'http://www.w3.org/2000/svg' ||
+                                s.hasAttribute('itemprop')) &&
+                                ((s = l.createElement(a)),
+                                l.head.insertBefore(
+                                  s,
+                                  l.querySelector('head > title'),
+                                )),
+                              te(s, a, n),
+                              (s[ne] = t),
+                              kt(s),
+                              (a = s))
+                            break t
+                          case 'link':
+                            var h = _d('link', 'href', l).get(
+                              a + (n.href || ''),
+                            )
+                            if (h) {
+                              for (var g = 0; g < h.length; g++)
+                                if (
+                                  ((s = h[g]),
+                                  s.getAttribute('href') ===
+                                    (n.href == null || n.href === ''
+                                      ? null
+                                      : n.href) &&
+                                    s.getAttribute('rel') ===
+                                      (n.rel == null ? null : n.rel) &&
+                                    s.getAttribute('title') ===
+                                      (n.title == null ? null : n.title) &&
+                                    s.getAttribute('crossorigin') ===
+                                      (n.crossOrigin == null
+                                        ? null
+                                        : n.crossOrigin))
+                                ) {
+                                  h.splice(g, 1)
+                                  break e
+                                }
+                            }
+                            ;((s = l.createElement(a)),
+                              te(s, a, n),
+                              l.head.appendChild(s))
+                            break
+                          case 'meta':
+                            if (
+                              (h = _d('meta', 'content', l).get(
+                                a + (n.content || ''),
+                              ))
+                            ) {
+                              for (g = 0; g < h.length; g++)
+                                if (
+                                  ((s = h[g]),
+                                  s.getAttribute('content') ===
+                                    (n.content == null
+                                      ? null
+                                      : '' + n.content) &&
+                                    s.getAttribute('name') ===
+                                      (n.name == null ? null : n.name) &&
+                                    s.getAttribute('property') ===
+                                      (n.property == null
+                                        ? null
+                                        : n.property) &&
+                                    s.getAttribute('http-equiv') ===
+                                      (n.httpEquiv == null
+                                        ? null
+                                        : n.httpEquiv) &&
+                                    s.getAttribute('charset') ===
+                                      (n.charSet == null ? null : n.charSet))
+                                ) {
+                                  h.splice(g, 1)
+                                  break e
+                                }
+                            }
+                            ;((s = l.createElement(a)),
+                              te(s, a, n),
+                              l.head.appendChild(s))
+                            break
+                          default:
+                            throw Error(f(468, a))
+                        }
+                        ;((s[ne] = t), kt(s), (a = s))
+                      }
+                      t.stateNode = a
+                    } else $d(l, t.type, t.stateNode)
+                  else t.stateNode = Pd(l, a, t.memoizedProps)
+                else
+                  s !== a
+                    ? (s === null
+                        ? n.stateNode !== null &&
+                          ((n = n.stateNode), n.parentNode.removeChild(n))
+                        : s.count--,
+                      a === null
+                        ? $d(l, t.type, t.stateNode)
+                        : Pd(l, a, t.memoizedProps))
+                    : a === null &&
+                      t.stateNode !== null &&
+                      js(t, t.memoizedProps, n.memoizedProps)
+              }
+              break
+            case 27:
+              ;(be(e, t),
+                pe(t),
+                a & 512 && (Gt || n === null || Ze(n, n.return)),
+                n !== null && a & 4 && js(t, t.memoizedProps, n.memoizedProps))
+              break
+            case 5:
+              if (
+                (be(e, t),
+                pe(t),
+                a & 512 && (Gt || n === null || Ze(n, n.return)),
+                t.flags & 32)
+              ) {
+                l = t.stateNode
+                try {
+                  Ua(l, '')
+                } catch (Y) {
+                  Ct(t, t.return, Y)
+                }
+              }
+              ;(a & 4 &&
+                t.stateNode != null &&
+                ((l = t.memoizedProps),
+                js(t, l, n !== null ? n.memoizedProps : l)),
+                a & 1024 && (Bs = !0))
+              break
+            case 6:
+              if ((be(e, t), pe(t), a & 4)) {
+                if (t.stateNode === null) throw Error(f(162))
+                ;((a = t.memoizedProps), (n = t.stateNode))
+                try {
+                  n.nodeValue = a
+                } catch (Y) {
+                  Ct(t, t.return, Y)
+                }
+              }
+              break
+            case 3:
+              if (
+                ((Qu = null),
+                (l = Ge),
+                (Ge = Bu(e.containerInfo)),
+                be(e, t),
+                (Ge = l),
+                pe(t),
+                a & 4 && n !== null && n.memoizedState.isDehydrated)
+              )
+                try {
+                  mi(e.containerInfo)
+                } catch (Y) {
+                  Ct(t, t.return, Y)
+                }
+              Bs && ((Bs = !1), id(t))
+              break
+            case 4:
+              ;((a = Ge),
+                (Ge = Bu(t.stateNode.containerInfo)),
+                be(e, t),
+                pe(t),
+                (Ge = a))
+              break
+            case 12:
+              ;(be(e, t), pe(t))
+              break
+            case 13:
+              ;(be(e, t),
+                pe(t),
+                t.child.flags & 8192 &&
+                  (t.memoizedState !== null) !=
+                    (n !== null && n.memoizedState !== null) &&
+                  (Xs = ce()),
+                a & 4 &&
+                  ((a = t.updateQueue),
+                  a !== null && ((t.updateQueue = null), Us(t, a))))
+              break
+            case 22:
+              l = t.memoizedState !== null
+              var S = n !== null && n.memoizedState !== null,
+                B = sn,
+                X = Gt
+              if (
+                ((sn = B || l),
+                (Gt = X || S),
+                be(e, t),
+                (Gt = X),
+                (sn = B),
+                pe(t),
+                a & 8192)
+              )
+                t: for (
+                  e = t.stateNode,
+                    e._visibility = l ? e._visibility & -2 : e._visibility | 1,
+                    l && (n === null || S || sn || Gt || ya(t)),
+                    n = null,
+                    e = t;
+                  ;
+                ) {
+                  if (e.tag === 5 || e.tag === 26) {
+                    if (n === null) {
+                      S = n = e
+                      try {
+                        if (((s = S.stateNode), l))
+                          ((h = s.style),
+                            typeof h.setProperty == 'function'
+                              ? h.setProperty('display', 'none', 'important')
+                              : (h.display = 'none'))
+                        else {
+                          g = S.stateNode
+                          var k = S.memoizedProps.style,
+                            Q =
+                              k != null && k.hasOwnProperty('display')
+                                ? k.display
+                                : null
+                          g.style.display =
+                            Q == null || typeof Q == 'boolean'
+                              ? ''
+                              : ('' + Q).trim()
+                        }
+                      } catch (Y) {
+                        Ct(S, S.return, Y)
+                      }
+                    }
+                  } else if (e.tag === 6) {
+                    if (n === null) {
+                      S = e
+                      try {
+                        S.stateNode.nodeValue = l ? '' : S.memoizedProps
+                      } catch (Y) {
+                        Ct(S, S.return, Y)
+                      }
+                    }
+                  } else if (
+                    ((e.tag !== 22 && e.tag !== 23) ||
+                      e.memoizedState === null ||
+                      e === t) &&
+                    e.child !== null
+                  ) {
+                    ;((e.child.return = e), (e = e.child))
+                    continue
+                  }
+                  if (e === t) break t
+                  for (; e.sibling === null; ) {
+                    if (e.return === null || e.return === t) break t
+                    ;(n === e && (n = null), (e = e.return))
+                  }
+                  ;(n === e && (n = null),
+                    (e.sibling.return = e.return),
+                    (e = e.sibling))
+                }
+              a & 4 &&
+                ((a = t.updateQueue),
+                a !== null &&
+                  ((n = a.retryQueue),
+                  n !== null && ((a.retryQueue = null), Us(t, n))))
+              break
+            case 19:
+              ;(be(e, t),
+                pe(t),
+                a & 4 &&
+                  ((a = t.updateQueue),
+                  a !== null && ((t.updateQueue = null), Us(t, a))))
+              break
+            case 30:
+              break
+            case 21:
+              break
+            default:
+              ;(be(e, t), pe(t))
+          }
+        }
+        function pe(t) {
+          var e = t.flags
+          if (e & 2) {
+            try {
+              for (var n, a = t.return; a !== null; ) {
+                if (P0(a)) {
+                  n = a
+                  break
+                }
+                a = a.return
+              }
+              if (n == null) throw Error(f(160))
+              switch (n.tag) {
+                case 27:
+                  var l = n.stateNode,
+                    s = Hs(t)
+                  pu(t, s, l)
+                  break
+                case 5:
+                  var h = n.stateNode
+                  n.flags & 32 && (Ua(h, ''), (n.flags &= -33))
+                  var g = Hs(t)
+                  pu(t, g, h)
+                  break
+                case 3:
+                case 4:
+                  var S = n.stateNode.containerInfo,
+                    B = Hs(t)
+                  Ns(t, B, S)
+                  break
+                default:
+                  throw Error(f(161))
+              }
+            } catch (X) {
+              Ct(t, t.return, X)
+            }
+            t.flags &= -3
+          }
+          e & 4096 && (t.flags &= -4097)
+        }
+        function id(t) {
+          if (t.subtreeFlags & 1024)
+            for (t = t.child; t !== null; ) {
+              var e = t
+              ;(id(e),
+                e.tag === 5 && e.flags & 1024 && e.stateNode.reset(),
+                (t = t.sibling))
+            }
+        }
+        function Hn(t, e) {
+          if (e.subtreeFlags & 8772)
+            for (e = e.child; e !== null; )
+              (td(t, e.alternate, e), (e = e.sibling))
+        }
+        function ya(t) {
+          for (t = t.child; t !== null; ) {
+            var e = t
+            switch (e.tag) {
+              case 0:
+              case 11:
+              case 14:
+              case 15:
+                ;(jn(4, e, e.return), ya(e))
+                break
+              case 1:
+                Ze(e, e.return)
+                var n = e.stateNode
+                ;(typeof n.componentWillUnmount == 'function' &&
+                  F0(e, e.return, n),
+                  ya(e))
+                break
+              case 27:
+                ci(e.stateNode)
+              case 26:
+              case 5:
+                ;(Ze(e, e.return), ya(e))
+                break
+              case 22:
+                e.memoizedState === null && ya(e)
+                break
+              case 30:
+                ya(e)
+                break
+              default:
+                ya(e)
+            }
+            t = t.sibling
+          }
+        }
+        function Nn(t, e, n) {
+          for (
+            n = n && (e.subtreeFlags & 8772) !== 0, e = e.child;
+            e !== null;
+          ) {
+            var a = e.alternate,
+              l = t,
+              s = e,
+              h = s.flags
+            switch (s.tag) {
+              case 0:
+              case 11:
+              case 15:
+                ;(Nn(l, s, n), Pl(4, s))
+                break
+              case 1:
+                if (
+                  (Nn(l, s, n),
+                  (a = s),
+                  (l = a.stateNode),
+                  typeof l.componentDidMount == 'function')
+                )
+                  try {
+                    l.componentDidMount()
+                  } catch (B) {
+                    Ct(a, a.return, B)
+                  }
+                if (((a = s), (l = a.updateQueue), l !== null)) {
+                  var g = a.stateNode
+                  try {
+                    var S = l.shared.hiddenCallbacks
+                    if (S !== null)
+                      for (
+                        l.shared.hiddenCallbacks = null, l = 0;
+                        l < S.length;
+                        l++
+                      )
+                        Bo(S[l], g)
+                  } catch (B) {
+                    Ct(a, a.return, B)
+                  }
+                }
+                ;(n && h & 64 && W0(s), _l(s, s.return))
+                break
+              case 27:
+                _0(s)
+              case 26:
+              case 5:
+                ;(Nn(l, s, n),
+                  n && a === null && h & 4 && J0(s),
+                  _l(s, s.return))
+                break
+              case 12:
+                Nn(l, s, n)
+                break
+              case 13:
+                ;(Nn(l, s, n), n && h & 4 && ad(l, s))
+                break
+              case 22:
+                ;(s.memoizedState === null && Nn(l, s, n), _l(s, s.return))
+                break
+              case 30:
+                break
+              default:
+                Nn(l, s, n)
+            }
+            e = e.sibling
+          }
+        }
+        function Qs(t, e) {
+          var n = null
+          ;(t !== null &&
+            t.memoizedState !== null &&
+            t.memoizedState.cachePool !== null &&
+            (n = t.memoizedState.cachePool.pool),
+            (t = null),
+            e.memoizedState !== null &&
+              e.memoizedState.cachePool !== null &&
+              (t = e.memoizedState.cachePool.pool),
+            t !== n && (t != null && t.refCount++, n != null && Yl(n)))
+        }
+        function Ys(t, e) {
+          ;((t = null),
+            e.alternate !== null && (t = e.alternate.memoizedState.cache),
+            (e = e.memoizedState.cache),
+            e !== t && (e.refCount++, t != null && Yl(t)))
+        }
+        function qe(t, e, n, a) {
+          if (e.subtreeFlags & 10256)
+            for (e = e.child; e !== null; ) (ud(t, e, n, a), (e = e.sibling))
+        }
+        function ud(t, e, n, a) {
+          var l = e.flags
+          switch (e.tag) {
+            case 0:
+            case 11:
+            case 15:
+              ;(qe(t, e, n, a), l & 2048 && Pl(9, e))
+              break
+            case 1:
+              qe(t, e, n, a)
+              break
+            case 3:
+              ;(qe(t, e, n, a),
+                l & 2048 &&
+                  ((t = null),
+                  e.alternate !== null && (t = e.alternate.memoizedState.cache),
+                  (e = e.memoizedState.cache),
+                  e !== t && (e.refCount++, t != null && Yl(t))))
+              break
+            case 12:
+              if (l & 2048) {
+                ;(qe(t, e, n, a), (t = e.stateNode))
+                try {
+                  var s = e.memoizedProps,
+                    h = s.id,
+                    g = s.onPostCommit
+                  typeof g == 'function' &&
+                    g(
+                      h,
+                      e.alternate === null ? 'mount' : 'update',
+                      t.passiveEffectDuration,
+                      -0,
+                    )
+                } catch (S) {
+                  Ct(e, e.return, S)
+                }
+              } else qe(t, e, n, a)
+              break
+            case 13:
+              qe(t, e, n, a)
+              break
+            case 23:
+              break
+            case 22:
+              ;((s = e.stateNode),
+                (h = e.alternate),
+                e.memoizedState !== null
+                  ? s._visibility & 2
+                    ? qe(t, e, n, a)
+                    : $l(t, e)
+                  : s._visibility & 2
+                    ? qe(t, e, n, a)
+                    : ((s._visibility |= 2),
+                      tl(t, e, n, a, (e.subtreeFlags & 10256) !== 0)),
+                l & 2048 && Qs(h, e))
+              break
+            case 24:
+              ;(qe(t, e, n, a), l & 2048 && Ys(e.alternate, e))
+              break
+            default:
+              qe(t, e, n, a)
+          }
+        }
+        function tl(t, e, n, a, l) {
+          for (
+            l = l && (e.subtreeFlags & 10256) !== 0, e = e.child;
+            e !== null;
+          ) {
+            var s = t,
+              h = e,
+              g = n,
+              S = a,
+              B = h.flags
+            switch (h.tag) {
+              case 0:
+              case 11:
+              case 15:
+                ;(tl(s, h, g, S, l), Pl(8, h))
+                break
+              case 23:
+                break
+              case 22:
+                var X = h.stateNode
+                ;(h.memoizedState !== null
+                  ? X._visibility & 2
+                    ? tl(s, h, g, S, l)
+                    : $l(s, h)
+                  : ((X._visibility |= 2), tl(s, h, g, S, l)),
+                  l && B & 2048 && Qs(h.alternate, h))
+                break
+              case 24:
+                ;(tl(s, h, g, S, l), l && B & 2048 && Ys(h.alternate, h))
+                break
+              default:
+                tl(s, h, g, S, l)
+            }
+            e = e.sibling
+          }
+        }
+        function $l(t, e) {
+          if (e.subtreeFlags & 10256)
+            for (e = e.child; e !== null; ) {
+              var n = t,
+                a = e,
+                l = a.flags
+              switch (a.tag) {
+                case 22:
+                  ;($l(n, a), l & 2048 && Qs(a.alternate, a))
+                  break
+                case 24:
+                  ;($l(n, a), l & 2048 && Ys(a.alternate, a))
+                  break
+                default:
+                  $l(n, a)
+              }
+              e = e.sibling
+            }
+        }
+        var ti = 8192
+        function el(t) {
+          if (t.subtreeFlags & ti)
+            for (t = t.child; t !== null; ) (cd(t), (t = t.sibling))
+        }
+        function cd(t) {
+          switch (t.tag) {
+            case 26:
+              ;(el(t),
+                t.flags & ti &&
+                  t.memoizedState !== null &&
+                  tA(Ge, t.memoizedState, t.memoizedProps))
+              break
+            case 5:
+              el(t)
+              break
+            case 3:
+            case 4:
+              var e = Ge
+              ;((Ge = Bu(t.stateNode.containerInfo)), el(t), (Ge = e))
+              break
+            case 22:
+              t.memoizedState === null &&
+                ((e = t.alternate),
+                e !== null && e.memoizedState !== null
+                  ? ((e = ti), (ti = 16777216), el(t), (ti = e))
+                  : el(t))
+              break
+            default:
+              el(t)
+          }
+        }
+        function sd(t) {
+          var e = t.alternate
+          if (e !== null && ((t = e.child), t !== null)) {
+            e.child = null
+            do ((e = t.sibling), (t.sibling = null), (t = e))
+            while (t !== null)
+          }
+        }
+        function ei(t) {
+          var e = t.deletions
+          if ((t.flags & 16) !== 0) {
+            if (e !== null)
+              for (var n = 0; n < e.length; n++) {
+                var a = e[n]
+                ;((Wt = a), rd(a, t))
+              }
+            sd(t)
+          }
+          if (t.subtreeFlags & 10256)
+            for (t = t.child; t !== null; ) (fd(t), (t = t.sibling))
+        }
+        function fd(t) {
+          switch (t.tag) {
+            case 0:
+            case 11:
+            case 15:
+              ;(ei(t), t.flags & 2048 && jn(9, t, t.return))
+              break
+            case 3:
+              ei(t)
+              break
+            case 12:
+              ei(t)
+              break
+            case 22:
+              var e = t.stateNode
+              t.memoizedState !== null &&
+              e._visibility & 2 &&
+              (t.return === null || t.return.tag !== 13)
+                ? ((e._visibility &= -3), xu(t))
+                : ei(t)
+              break
+            default:
+              ei(t)
+          }
+        }
+        function xu(t) {
+          var e = t.deletions
+          if ((t.flags & 16) !== 0) {
+            if (e !== null)
+              for (var n = 0; n < e.length; n++) {
+                var a = e[n]
+                ;((Wt = a), rd(a, t))
+              }
+            sd(t)
+          }
+          for (t = t.child; t !== null; ) {
+            switch (((e = t), e.tag)) {
+              case 0:
+              case 11:
+              case 15:
+                ;(jn(8, e, e.return), xu(e))
+                break
+              case 22:
+                ;((n = e.stateNode),
+                  n._visibility & 2 && ((n._visibility &= -3), xu(e)))
+                break
+              default:
+                xu(e)
+            }
+            t = t.sibling
+          }
+        }
+        function rd(t, e) {
+          for (; Wt !== null; ) {
+            var n = Wt
+            switch (n.tag) {
+              case 0:
+              case 11:
+              case 15:
+                jn(8, n, e)
+                break
+              case 23:
+              case 22:
+                if (
+                  n.memoizedState !== null &&
+                  n.memoizedState.cachePool !== null
+                ) {
+                  var a = n.memoizedState.cachePool.pool
+                  a != null && a.refCount++
+                }
+                break
+              case 24:
+                Yl(n.memoizedState.cache)
+            }
+            if (((a = n.child), a !== null)) ((a.return = n), (Wt = a))
+            else
+              t: for (n = t; Wt !== null; ) {
+                a = Wt
+                var l = a.sibling,
+                  s = a.return
+                if ((ed(a), a === n)) {
+                  Wt = null
+                  break t
+                }
+                if (l !== null) {
+                  ;((l.return = s), (Wt = l))
+                  break t
+                }
+                Wt = s
+              }
+          }
+        }
+        var Am = {
+            getCacheForType: function (t) {
+              var e = ae(It),
+                n = e.data.get(t)
+              return (n === void 0 && ((n = t()), e.data.set(t, n)), n)
+            },
+          },
+          vm = typeof WeakMap == 'function' ? WeakMap : Map,
+          St = 0,
+          Mt = null,
+          vt = null,
+          Et = 0,
+          Tt = 0,
+          xe = null,
+          Bn = !1,
+          nl = !1,
+          Ls = !1,
+          rn = 0,
+          Lt = 0,
+          Un = 0,
+          Ea = 0,
+          zs = 0,
+          Ne = 0,
+          al = 0,
+          ni = null,
+          ge = null,
+          Gs = !1,
+          Xs = 0,
+          Su = 1 / 0,
+          Tu = null,
+          Qn = null,
+          $t = 0,
+          Yn = null,
+          ll = null,
+          il = 0,
+          Vs = 0,
+          Is = null,
+          od = null,
+          ai = 0,
+          Zs = null
+        function Se() {
+          if ((St & 2) !== 0 && Et !== 0) return Et & -Et
+          if (M.T !== null) {
+            var t = ka
+            return t !== 0 ? t : Ps()
+          }
+          return Rr()
+        }
+        function dd() {
+          Ne === 0 && (Ne = (Et & 536870912) === 0 || xt ? xr() : 536870912)
+          var t = He.current
+          return (t !== null && (t.flags |= 32), Ne)
+        }
+        function Te(t, e, n) {
+          ;(((t === Mt && (Tt === 2 || Tt === 9)) ||
+            t.cancelPendingCommit !== null) &&
+            (ul(t, 0), Ln(t, Et, Ne, !1)),
+            pl(t, n),
+            ((St & 2) === 0 || t !== Mt) &&
+              (t === Mt &&
+                ((St & 2) === 0 && (Ea |= n), Lt === 4 && Ln(t, Et, Ne, !1)),
+              ke(t)))
+        }
+        function hd(t, e, n) {
+          if ((St & 6) !== 0) throw Error(f(327))
+          var a =
+              (!n && (e & 124) === 0 && (e & t.expiredLanes) === 0) || bl(t, e),
+            l = a ? bm(t, e) : Ks(t, e, !0),
+            s = a
+          do {
+            if (l === 0) {
+              nl && !a && Ln(t, e, 0, !1)
+              break
+            } else {
+              if (((n = t.current.alternate), s && !ym(n))) {
+                ;((l = Ks(t, e, !1)), (s = !1))
+                continue
+              }
+              if (l === 2) {
+                if (((s = e), t.errorRecoveryDisabledLanes & s)) var h = 0
+                else
+                  ((h = t.pendingLanes & -536870913),
+                    (h = h !== 0 ? h : h & 536870912 ? 536870912 : 0))
+                if (h !== 0) {
+                  e = h
+                  t: {
+                    var g = t
+                    l = ni
+                    var S = g.current.memoizedState.isDehydrated
+                    if (
+                      (S && (ul(g, h).flags |= 256),
+                      (h = Ks(g, h, !1)),
+                      h !== 2)
+                    ) {
+                      if (Ls && !S) {
+                        ;((g.errorRecoveryDisabledLanes |= s),
+                          (Ea |= s),
+                          (l = 4))
+                        break t
+                      }
+                      ;((s = ge),
+                        (ge = l),
+                        s !== null &&
+                          (ge === null ? (ge = s) : ge.push.apply(ge, s)))
+                    }
+                    l = h
+                  }
+                  if (((s = !1), l !== 2)) continue
+                }
+              }
+              if (l === 1) {
+                ;(ul(t, 0), Ln(t, e, 0, !0))
+                break
+              }
+              t: {
+                switch (((a = t), (s = l), s)) {
+                  case 0:
+                  case 1:
+                    throw Error(f(345))
+                  case 4:
+                    if ((e & 4194048) !== e) break
+                  case 6:
+                    Ln(a, e, Ne, !Bn)
+                    break t
+                  case 2:
+                    ge = null
+                    break
+                  case 3:
+                  case 5:
+                    break
+                  default:
+                    throw Error(f(329))
+                }
+                if ((e & 62914560) === e && ((l = Xs + 300 - ce()), 10 < l)) {
+                  if ((Ln(a, e, Ne, !Bn), Ui(a, 0, !0) !== 0)) break t
+                  a.timeoutHandle = Vd(
+                    gd.bind(
+                      null,
+                      a,
+                      n,
+                      ge,
+                      Tu,
+                      Gs,
+                      e,
+                      Ne,
+                      Ea,
+                      al,
+                      Bn,
+                      s,
+                      2,
+                      -0,
+                      0,
+                    ),
+                    l,
+                  )
+                  break t
+                }
+                gd(a, n, ge, Tu, Gs, e, Ne, Ea, al, Bn, s, 0, -0, 0)
+              }
+            }
+            break
+          } while (!0)
+          ke(t)
+        }
+        function gd(t, e, n, a, l, s, h, g, S, B, X, k, Q, Y) {
+          if (
+            ((t.timeoutHandle = -1),
+            (k = e.subtreeFlags),
+            (k & 8192 || (k & 16785408) === 16785408) &&
+              ((ri = { stylesheets: null, count: 0, unsuspend: $m }),
+              cd(e),
+              (k = eA()),
+              k !== null))
+          ) {
+            ;((t.cancelPendingCommit = k(
+              pd.bind(null, t, e, s, n, a, l, h, g, S, X, 1, Q, Y),
+            )),
+              Ln(t, s, h, !B))
+            return
+          }
+          pd(t, e, s, n, a, l, h, g, S)
+        }
+        function ym(t) {
+          for (var e = t; ; ) {
+            var n = e.tag
+            if (
+              (n === 0 || n === 11 || n === 15) &&
+              e.flags & 16384 &&
+              ((n = e.updateQueue), n !== null && ((n = n.stores), n !== null))
+            )
+              for (var a = 0; a < n.length; a++) {
+                var l = n[a],
+                  s = l.getSnapshot
+                l = l.value
+                try {
+                  if (!ye(s(), l)) return !1
+                } catch {
+                  return !1
+                }
+              }
+            if (((n = e.child), e.subtreeFlags & 16384 && n !== null))
+              ((n.return = e), (e = n))
+            else {
+              if (e === t) break
+              for (; e.sibling === null; ) {
+                if (e.return === null || e.return === t) return !0
+                e = e.return
+              }
+              ;((e.sibling.return = e.return), (e = e.sibling))
+            }
+          }
+          return !0
+        }
+        function Ln(t, e, n, a) {
+          ;((e &= ~zs),
+            (e &= ~Ea),
+            (t.suspendedLanes |= e),
+            (t.pingedLanes &= ~e),
+            a && (t.warmLanes |= e),
+            (a = t.expirationTimes))
+          for (var l = e; 0 < l; ) {
+            var s = 31 - ve(l),
+              h = 1 << s
+            ;((a[s] = -1), (l &= ~h))
+          }
+          n !== 0 && Tr(t, n, e)
+        }
+        function wu() {
+          return (St & 6) === 0 ? (li(0), !1) : !0
+        }
+        function qs() {
+          if (vt !== null) {
+            if (Tt === 0) var t = vt.return
+            else
+              ((t = vt),
+                (en = ha = null),
+                ss(t),
+                (_a = null),
+                (Wl = 0),
+                (t = vt))
+            for (; t !== null; ) (K0(t.alternate, t), (t = t.return))
+            vt = null
+          }
+        }
+        function ul(t, e) {
+          var n = t.timeoutHandle
+          ;(n !== -1 && ((t.timeoutHandle = -1), Qm(n)),
+            (n = t.cancelPendingCommit),
+            n !== null && ((t.cancelPendingCommit = null), n()),
+            qs(),
+            (Mt = t),
+            (vt = n = _e(t.current, null)),
+            (Et = e),
+            (Tt = 0),
+            (xe = null),
+            (Bn = !1),
+            (nl = bl(t, e)),
+            (Ls = !1),
+            (al = Ne = zs = Ea = Un = Lt = 0),
+            (ge = ni = null),
+            (Gs = !1),
+            (e & 8) !== 0 && (e |= e & 32))
+          var a = t.entangledLanes
+          if (a !== 0)
+            for (t = t.entanglements, a &= e; 0 < a; ) {
+              var l = 31 - ve(a),
+                s = 1 << l
+              ;((e |= t[l]), (a &= ~s))
+            }
+          return ((rn = e), Ki(), n)
+        }
+        function md(t, e) {
+          ;((gt = null),
+            (M.H = du),
+            e === zl || e === nu
+              ? ((e = Ho()), (Tt = 3))
+              : e === Co
+                ? ((e = Ho()), (Tt = 4))
+                : (Tt =
+                    e === N0
+                      ? 8
+                      : e !== null &&
+                          typeof e == 'object' &&
+                          typeof e.then == 'function'
+                        ? 6
+                        : 1),
+            (xe = e),
+            vt === null && ((Lt = 1), vu(t, De(e, t.current))))
+        }
+        function Ad() {
+          var t = M.H
+          return ((M.H = du), t === null ? du : t)
+        }
+        function vd() {
+          var t = M.A
+          return ((M.A = Am), t)
+        }
+        function ks() {
+          ;((Lt = 4),
+            Bn || ((Et & 4194048) !== Et && He.current !== null) || (nl = !0),
+            ((Un & 134217727) === 0 && (Ea & 134217727) === 0) ||
+              Mt === null ||
+              Ln(Mt, Et, Ne, !1))
+        }
+        function Ks(t, e, n) {
+          var a = St
+          St |= 2
+          var l = Ad(),
+            s = vd()
+          ;((Mt !== t || Et !== e) && ((Tu = null), ul(t, e)), (e = !1))
+          var h = Lt
+          t: do
+            try {
+              if (Tt !== 0 && vt !== null) {
+                var g = vt,
+                  S = xe
+                switch (Tt) {
+                  case 8:
+                    ;(qs(), (h = 6))
+                    break t
+                  case 3:
+                  case 2:
+                  case 9:
+                  case 6:
+                    He.current === null && (e = !0)
+                    var B = Tt
+                    if (((Tt = 0), (xe = null), cl(t, g, S, B), n && nl)) {
+                      h = 0
+                      break t
+                    }
+                    break
+                  default:
+                    ;((B = Tt), (Tt = 0), (xe = null), cl(t, g, S, B))
+                }
+              }
+              ;(Em(), (h = Lt))
+              break
+            } catch (X) {
+              md(t, X)
+            }
+          while (!0)
+          return (
+            e && t.shellSuspendCounter++,
+            (en = ha = null),
+            (St = a),
+            (M.H = l),
+            (M.A = s),
+            vt === null && ((Mt = null), (Et = 0), Ki()),
+            h
+          )
+        }
+        function Em() {
+          for (; vt !== null; ) yd(vt)
+        }
+        function bm(t, e) {
+          var n = St
+          St |= 2
+          var a = Ad(),
+            l = vd()
+          Mt !== t || Et !== e
+            ? ((Tu = null), (Su = ce() + 500), ul(t, e))
+            : (nl = bl(t, e))
+          t: do
+            try {
+              if (Tt !== 0 && vt !== null) {
+                e = vt
+                var s = xe
+                e: switch (Tt) {
+                  case 1:
+                    ;((Tt = 0), (xe = null), cl(t, e, s, 1))
+                    break
+                  case 2:
+                  case 9:
+                    if (Mo(s)) {
+                      ;((Tt = 0), (xe = null), Ed(e))
+                      break
+                    }
+                    ;((e = function () {
+                      ;((Tt !== 2 && Tt !== 9) || Mt !== t || (Tt = 7), ke(t))
+                    }),
+                      s.then(e, e))
+                    break t
+                  case 3:
+                    Tt = 7
+                    break t
+                  case 4:
+                    Tt = 5
+                    break t
+                  case 7:
+                    Mo(s)
+                      ? ((Tt = 0), (xe = null), Ed(e))
+                      : ((Tt = 0), (xe = null), cl(t, e, s, 7))
+                    break
+                  case 5:
+                    var h = null
+                    switch (vt.tag) {
+                      case 26:
+                        h = vt.memoizedState
+                      case 5:
+                      case 27:
+                        var g = vt
+                        if (!h || t1(h)) {
+                          ;((Tt = 0), (xe = null))
+                          var S = g.sibling
+                          if (S !== null) vt = S
+                          else {
+                            var B = g.return
+                            B !== null ? ((vt = B), Ru(B)) : (vt = null)
+                          }
+                          break e
+                        }
+                    }
+                    ;((Tt = 0), (xe = null), cl(t, e, s, 5))
+                    break
+                  case 6:
+                    ;((Tt = 0), (xe = null), cl(t, e, s, 6))
+                    break
+                  case 8:
+                    ;(qs(), (Lt = 6))
+                    break t
+                  default:
+                    throw Error(f(462))
+                }
+              }
+              pm()
+              break
+            } catch (X) {
+              md(t, X)
+            }
+          while (!0)
+          return (
+            (en = ha = null),
+            (M.H = a),
+            (M.A = l),
+            (St = n),
+            vt !== null ? 0 : ((Mt = null), (Et = 0), Ki(), Lt)
+          )
+        }
+        function pm() {
+          for (; vt !== null && !ji(); ) yd(vt)
+        }
+        function yd(t) {
+          var e = q0(t.alternate, t, rn)
+          ;((t.memoizedProps = t.pendingProps), e === null ? Ru(t) : (vt = e))
+        }
+        function Ed(t) {
+          var e = t,
+            n = e.alternate
+          switch (e.tag) {
+            case 15:
+            case 0:
+              e = z0(n, e, e.pendingProps, e.type, void 0, Et)
+              break
+            case 11:
+              e = z0(n, e, e.pendingProps, e.type.render, e.ref, Et)
+              break
+            case 5:
+              ss(e)
+            default:
+              ;(K0(n, e), (e = vt = bo(e, rn)), (e = q0(n, e, rn)))
+          }
+          ;((t.memoizedProps = t.pendingProps), e === null ? Ru(t) : (vt = e))
+        }
+        function cl(t, e, n, a) {
+          ;((en = ha = null), ss(e), (_a = null), (Wl = 0))
+          var l = e.return
+          try {
+            if (rm(t, l, e, n, Et)) {
+              ;((Lt = 1), vu(t, De(n, t.current)), (vt = null))
+              return
+            }
+          } catch (s) {
+            if (l !== null) throw ((vt = l), s)
+            ;((Lt = 1), vu(t, De(n, t.current)), (vt = null))
+            return
+          }
+          e.flags & 32768
+            ? (xt || a === 1
+                ? (t = !0)
+                : nl || (Et & 536870912) !== 0
+                  ? (t = !1)
+                  : ((Bn = t = !0),
+                    (a === 2 || a === 9 || a === 3 || a === 6) &&
+                      ((a = He.current),
+                      a !== null && a.tag === 13 && (a.flags |= 16384))),
+              bd(e, t))
+            : Ru(e)
+        }
+        function Ru(t) {
+          var e = t
+          do {
+            if ((e.flags & 32768) !== 0) {
+              bd(e, Bn)
+              return
+            }
+            t = e.return
+            var n = dm(e.alternate, e, rn)
+            if (n !== null) {
+              vt = n
+              return
+            }
+            if (((e = e.sibling), e !== null)) {
+              vt = e
+              return
+            }
+            vt = e = t
+          } while (e !== null)
+          Lt === 0 && (Lt = 5)
+        }
+        function bd(t, e) {
+          do {
+            var n = hm(t.alternate, t)
+            if (n !== null) {
+              ;((n.flags &= 32767), (vt = n))
+              return
+            }
+            if (
+              ((n = t.return),
+              n !== null &&
+                ((n.flags |= 32768),
+                (n.subtreeFlags = 0),
+                (n.deletions = null)),
+              !e && ((t = t.sibling), t !== null))
+            ) {
+              vt = t
+              return
+            }
+            vt = t = n
+          } while (t !== null)
+          ;((Lt = 6), (vt = null))
+        }
+        function pd(t, e, n, a, l, s, h, g, S) {
+          t.cancelPendingCommit = null
+          do Ou()
+          while ($t !== 0)
+          if ((St & 6) !== 0) throw Error(f(327))
+          if (e !== null) {
+            if (e === t.current) throw Error(f(177))
+            if (
+              ((s = e.lanes | e.childLanes),
+              (s |= Yc),
+              $h(t, n, s, h, g, S),
+              t === Mt && ((vt = Mt = null), (Et = 0)),
+              (ll = e),
+              (Yn = t),
+              (il = n),
+              (Vs = s),
+              (Is = l),
+              (od = a),
+              (e.subtreeFlags & 10256) !== 0 || (e.flags & 10256) !== 0
+                ? ((t.callbackNode = null),
+                  (t.callbackPriority = 0),
+                  wm(Hi, function () {
+                    return (Rd(), null)
+                  }))
+                : ((t.callbackNode = null), (t.callbackPriority = 0)),
+              (a = (e.flags & 13878) !== 0),
+              (e.subtreeFlags & 13878) !== 0 || a)
+            ) {
+              ;((a = M.T),
+                (M.T = null),
+                (l = _.p),
+                (_.p = 2),
+                (h = St),
+                (St |= 4))
+              try {
+                gm(t, e, n)
+              } finally {
+                ;((St = h), (_.p = l), (M.T = a))
+              }
+            }
+            ;(($t = 1), xd(), Sd(), Td())
+          }
+        }
+        function xd() {
+          if ($t === 1) {
+            $t = 0
+            var t = Yn,
+              e = ll,
+              n = (e.flags & 13878) !== 0
+            if ((e.subtreeFlags & 13878) !== 0 || n) {
+              ;((n = M.T), (M.T = null))
+              var a = _.p
+              _.p = 2
+              var l = St
+              St |= 4
+              try {
+                ld(e, t)
+                var s = uf,
+                  h = fo(t.containerInfo),
+                  g = s.focusedElem,
+                  S = s.selectionRange
+                if (
+                  h !== g &&
+                  g &&
+                  g.ownerDocument &&
+                  so(g.ownerDocument.documentElement, g)
+                ) {
+                  if (S !== null && Hc(g)) {
+                    var B = S.start,
+                      X = S.end
+                    if ((X === void 0 && (X = B), 'selectionStart' in g))
+                      ((g.selectionStart = B),
+                        (g.selectionEnd = Math.min(X, g.value.length)))
+                    else {
+                      var k = g.ownerDocument || document,
+                        Q = (k && k.defaultView) || window
+                      if (Q.getSelection) {
+                        var Y = Q.getSelection(),
+                          rt = g.textContent.length,
+                          st = Math.min(S.start, rt),
+                          Ot = S.end === void 0 ? st : Math.min(S.end, rt)
+                        !Y.extend && st > Ot && ((h = Ot), (Ot = st), (st = h))
+                        var C = co(g, st),
+                          O = co(g, Ot)
+                        if (
+                          C &&
+                          O &&
+                          (Y.rangeCount !== 1 ||
+                            Y.anchorNode !== C.node ||
+                            Y.anchorOffset !== C.offset ||
+                            Y.focusNode !== O.node ||
+                            Y.focusOffset !== O.offset)
+                        ) {
+                          var H = k.createRange()
+                          ;(H.setStart(C.node, C.offset),
+                            Y.removeAllRanges(),
+                            st > Ot
+                              ? (Y.addRange(H), Y.extend(O.node, O.offset))
+                              : (H.setEnd(O.node, O.offset), Y.addRange(H)))
+                        }
+                      }
+                    }
+                  }
+                  for (k = [], Y = g; (Y = Y.parentNode); )
+                    Y.nodeType === 1 &&
+                      k.push({
+                        element: Y,
+                        left: Y.scrollLeft,
+                        top: Y.scrollTop,
+                      })
+                  for (
+                    typeof g.focus == 'function' && g.focus(), g = 0;
+                    g < k.length;
+                    g++
+                  ) {
+                    var Z = k[g]
+                    ;((Z.element.scrollLeft = Z.left),
+                      (Z.element.scrollTop = Z.top))
+                  }
+                }
+                ;((zu = !!lf), (uf = lf = null))
+              } finally {
+                ;((St = l), (_.p = a), (M.T = n))
+              }
+            }
+            ;((t.current = e), ($t = 2))
+          }
+        }
+        function Sd() {
+          if ($t === 2) {
+            $t = 0
+            var t = Yn,
+              e = ll,
+              n = (e.flags & 8772) !== 0
+            if ((e.subtreeFlags & 8772) !== 0 || n) {
+              ;((n = M.T), (M.T = null))
+              var a = _.p
+              _.p = 2
+              var l = St
+              St |= 4
+              try {
+                td(t, e.alternate, e)
+              } finally {
+                ;((St = l), (_.p = a), (M.T = n))
+              }
+            }
+            $t = 3
+          }
+        }
+        function Td() {
+          if ($t === 4 || $t === 3) {
+            ;(($t = 0), Oa())
+            var t = Yn,
+              e = ll,
+              n = il,
+              a = od
+            ;(e.subtreeFlags & 10256) !== 0 || (e.flags & 10256) !== 0
+              ? ($t = 5)
+              : (($t = 0), (ll = Yn = null), wd(t, t.pendingLanes))
+            var l = t.pendingLanes
+            if (
+              (l === 0 && (Qn = null),
+              oc(n),
+              (e = e.stateNode),
+              Ae && typeof Ae.onCommitFiberRoot == 'function')
+            )
+              try {
+                Ae.onCommitFiberRoot(
+                  El,
+                  e,
+                  void 0,
+                  (e.current.flags & 128) === 128,
+                )
+              } catch {}
+            if (a !== null) {
+              ;((e = M.T), (l = _.p), (_.p = 2), (M.T = null))
+              try {
+                for (var s = t.onRecoverableError, h = 0; h < a.length; h++) {
+                  var g = a[h]
+                  s(g.value, { componentStack: g.stack })
+                }
+              } finally {
+                ;((M.T = e), (_.p = l))
+              }
+            }
+            ;((il & 3) !== 0 && Ou(),
+              ke(t),
+              (l = t.pendingLanes),
+              (n & 4194090) !== 0 && (l & 42) !== 0
+                ? t === Zs
+                  ? ai++
+                  : ((ai = 0), (Zs = t))
+                : (ai = 0),
+              li(0))
+          }
+        }
+        function wd(t, e) {
+          ;(t.pooledCacheLanes &= e) === 0 &&
+            ((e = t.pooledCache), e != null && ((t.pooledCache = null), Yl(e)))
+        }
+        function Ou(t) {
+          return (xd(), Sd(), Td(), Rd())
+        }
+        function Rd() {
+          if ($t !== 5) return !1
+          var t = Yn,
+            e = Vs
+          Vs = 0
+          var n = oc(il),
+            a = M.T,
+            l = _.p
+          try {
+            ;((_.p = 32 > n ? 32 : n), (M.T = null), (n = Is), (Is = null))
+            var s = Yn,
+              h = il
+            if ((($t = 0), (ll = Yn = null), (il = 0), (St & 6) !== 0))
+              throw Error(f(331))
+            var g = St
+            if (
+              ((St |= 4),
+              fd(s.current),
+              ud(s, s.current, h, n),
+              (St = g),
+              li(0, !1),
+              Ae && typeof Ae.onPostCommitFiberRoot == 'function')
+            )
+              try {
+                Ae.onPostCommitFiberRoot(El, s)
+              } catch {}
+            return !0
+          } finally {
+            ;((_.p = l), (M.T = a), wd(t, e))
+          }
+        }
+        function Od(t, e, n) {
+          ;((e = De(n, e)),
+            (e = xs(t.stateNode, e, 2)),
+            (t = On(t, e, 2)),
+            t !== null && (pl(t, 2), ke(t)))
+        }
+        function Ct(t, e, n) {
+          if (t.tag === 3) Od(t, t, n)
+          else
+            for (; e !== null; ) {
+              if (e.tag === 3) {
+                Od(e, t, n)
+                break
+              } else if (e.tag === 1) {
+                var a = e.stateNode
+                if (
+                  typeof e.type.getDerivedStateFromError == 'function' ||
+                  (typeof a.componentDidCatch == 'function' &&
+                    (Qn === null || !Qn.has(a)))
+                ) {
+                  ;((t = De(n, t)),
+                    (n = j0(2)),
+                    (a = On(e, n, 2)),
+                    a !== null && (H0(n, a, e, t), pl(a, 2), ke(a)))
+                  break
+                }
+              }
+              e = e.return
+            }
+        }
+        function Ws(t, e, n) {
+          var a = t.pingCache
+          if (a === null) {
+            a = t.pingCache = new vm()
+            var l = new Set()
+            a.set(e, l)
+          } else
+            ((l = a.get(e)), l === void 0 && ((l = new Set()), a.set(e, l)))
+          l.has(n) ||
+            ((Ls = !0), l.add(n), (t = xm.bind(null, t, e, n)), e.then(t, t))
+        }
+        function xm(t, e, n) {
+          var a = t.pingCache
+          ;(a !== null && a.delete(e),
+            (t.pingedLanes |= t.suspendedLanes & n),
+            (t.warmLanes &= ~n),
+            Mt === t &&
+              (Et & n) === n &&
+              (Lt === 4 ||
+              (Lt === 3 && (Et & 62914560) === Et && 300 > ce() - Xs)
+                ? (St & 2) === 0 && ul(t, 0)
+                : (zs |= n),
+              al === Et && (al = 0)),
+            ke(t))
+        }
+        function Dd(t, e) {
+          ;(e === 0 && (e = Sr()),
+            (t = Va(t, e)),
+            t !== null && (pl(t, e), ke(t)))
+        }
+        function Sm(t) {
+          var e = t.memoizedState,
+            n = 0
+          ;(e !== null && (n = e.retryLane), Dd(t, n))
+        }
+        function Tm(t, e) {
+          var n = 0
+          switch (t.tag) {
+            case 13:
+              var a = t.stateNode,
+                l = t.memoizedState
+              l !== null && (n = l.retryLane)
+              break
+            case 19:
+              a = t.stateNode
+              break
+            case 22:
+              a = t.stateNode._retryCache
+              break
+            default:
+              throw Error(f(314))
+          }
+          ;(a !== null && a.delete(e), Dd(t, n))
+        }
+        function wm(t, e) {
+          return na(t, e)
+        }
+        var Du = null,
+          sl = null,
+          Fs = !1,
+          Cu = !1,
+          Js = !1,
+          ba = 0
+        function ke(t) {
+          ;(t !== sl &&
+            t.next === null &&
+            (sl === null ? (Du = sl = t) : (sl = sl.next = t)),
+            (Cu = !0),
+            Fs || ((Fs = !0), Om()))
+        }
+        function li(t, e) {
+          if (!Js && Cu) {
+            Js = !0
+            do
+              for (var n = !1, a = Du; a !== null; ) {
+                if (t !== 0) {
+                  var l = a.pendingLanes
+                  if (l === 0) var s = 0
+                  else {
+                    var h = a.suspendedLanes,
+                      g = a.pingedLanes
+                    ;((s = (1 << (31 - ve(42 | t) + 1)) - 1),
+                      (s &= l & ~(h & ~g)),
+                      (s = s & 201326741 ? (s & 201326741) | 1 : s ? s | 2 : 0))
+                  }
+                  s !== 0 && ((n = !0), Hd(a, s))
+                } else
+                  ((s = Et),
+                    (s = Ui(
+                      a,
+                      a === Mt ? s : 0,
+                      a.cancelPendingCommit !== null || a.timeoutHandle !== -1,
+                    )),
+                    (s & 3) === 0 || bl(a, s) || ((n = !0), Hd(a, s)))
+                a = a.next
+              }
+            while (n)
+            Js = !1
+          }
+        }
+        function Rm() {
+          Cd()
+        }
+        function Cd() {
+          Cu = Fs = !1
+          var t = 0
+          ba !== 0 && (Um() && (t = ba), (ba = 0))
+          for (var e = ce(), n = null, a = Du; a !== null; ) {
+            var l = a.next,
+              s = Md(a, e)
+            ;(s === 0
+              ? ((a.next = null),
+                n === null ? (Du = l) : (n.next = l),
+                l === null && (sl = n))
+              : ((n = a), (t !== 0 || (s & 3) !== 0) && (Cu = !0)),
+              (a = l))
+          }
+          li(t)
+        }
+        function Md(t, e) {
+          for (
+            var n = t.suspendedLanes,
+              a = t.pingedLanes,
+              l = t.expirationTimes,
+              s = t.pendingLanes & -62914561;
+            0 < s;
+          ) {
+            var h = 31 - ve(s),
+              g = 1 << h,
+              S = l[h]
+            ;(S === -1
+              ? ((g & n) === 0 || (g & a) !== 0) && (l[h] = _h(g, e))
+              : S <= e && (t.expiredLanes |= g),
+              (s &= ~g))
+          }
+          if (
+            ((e = Mt),
+            (n = Et),
+            (n = Ui(
+              t,
+              t === e ? n : 0,
+              t.cancelPendingCommit !== null || t.timeoutHandle !== -1,
+            )),
+            (a = t.callbackNode),
+            n === 0 ||
+              (t === e && (Tt === 2 || Tt === 9)) ||
+              t.cancelPendingCommit !== null)
+          )
+            return (
+              a !== null && a !== null && Fe(a),
+              (t.callbackNode = null),
+              (t.callbackPriority = 0)
+            )
+          if ((n & 3) === 0 || bl(t, n)) {
+            if (((e = n & -n), e === t.callbackPriority)) return e
+            switch ((a !== null && Fe(a), oc(n))) {
+              case 2:
+              case 8:
+                n = br
+                break
+              case 32:
+                n = Hi
+                break
+              case 268435456:
+                n = pr
+                break
+              default:
+                n = Hi
+            }
+            return (
+              (a = jd.bind(null, t)),
+              (n = na(n, a)),
+              (t.callbackPriority = e),
+              (t.callbackNode = n),
+              e
+            )
+          }
+          return (
+            a !== null && a !== null && Fe(a),
+            (t.callbackPriority = 2),
+            (t.callbackNode = null),
+            2
+          )
+        }
+        function jd(t, e) {
+          if ($t !== 0 && $t !== 5)
+            return ((t.callbackNode = null), (t.callbackPriority = 0), null)
+          var n = t.callbackNode
+          if (Ou() && t.callbackNode !== n) return null
+          var a = Et
+          return (
+            (a = Ui(
+              t,
+              t === Mt ? a : 0,
+              t.cancelPendingCommit !== null || t.timeoutHandle !== -1,
+            )),
+            a === 0
+              ? null
+              : (hd(t, a, e),
+                Md(t, ce()),
+                t.callbackNode != null && t.callbackNode === n
+                  ? jd.bind(null, t)
+                  : null)
+          )
+        }
+        function Hd(t, e) {
+          if (Ou()) return null
+          hd(t, e, !0)
+        }
+        function Om() {
+          Ym(function () {
+            ;(St & 6) !== 0 ? na(Er, Rm) : Cd()
+          })
+        }
+        function Ps() {
+          return (ba === 0 && (ba = xr()), ba)
+        }
+        function Nd(t) {
+          return t == null || typeof t == 'symbol' || typeof t == 'boolean'
+            ? null
+            : typeof t == 'function'
+              ? t
+              : Gi('' + t)
+        }
+        function Bd(t, e) {
+          var n = e.ownerDocument.createElement('input')
+          return (
+            (n.name = e.name),
+            (n.value = e.value),
+            t.id && n.setAttribute('form', t.id),
+            e.parentNode.insertBefore(n, e),
+            (t = new FormData(t)),
+            n.parentNode.removeChild(n),
+            t
+          )
+        }
+        function Dm(t, e, n, a, l) {
+          if (e === 'submit' && n && n.stateNode === l) {
+            var s = Nd((l[re] || null).action),
+              h = a.submitter
+            h &&
+              ((e = (e = h[re] || null)
+                ? Nd(e.formAction)
+                : h.getAttribute('formAction')),
+              e !== null && ((s = e), (h = null)))
+            var g = new Zi('action', 'action', null, a, l)
+            t.push({
+              event: g,
+              listeners: [
+                {
+                  instance: null,
+                  listener: function () {
+                    if (a.defaultPrevented) {
+                      if (ba !== 0) {
+                        var S = h ? Bd(l, h) : new FormData(l)
+                        vs(
+                          n,
+                          { pending: !0, data: S, method: l.method, action: s },
+                          null,
+                          S,
+                        )
+                      }
+                    } else
+                      typeof s == 'function' &&
+                        (g.preventDefault(),
+                        (S = h ? Bd(l, h) : new FormData(l)),
+                        vs(
+                          n,
+                          { pending: !0, data: S, method: l.method, action: s },
+                          s,
+                          S,
+                        ))
+                  },
+                  currentTarget: l,
+                },
+              ],
+            })
+          }
+        }
+        for (var _s = 0; _s < Qc.length; _s++) {
+          var $s = Qc[_s],
+            Cm = $s.toLowerCase(),
+            Mm = $s[0].toUpperCase() + $s.slice(1)
+          ze(Cm, 'on' + Mm)
+        }
+        ;(ze(ho, 'onAnimationEnd'),
+          ze(go, 'onAnimationIteration'),
+          ze(mo, 'onAnimationStart'),
+          ze('dblclick', 'onDoubleClick'),
+          ze('focusin', 'onFocus'),
+          ze('focusout', 'onBlur'),
+          ze(Kg, 'onTransitionRun'),
+          ze(Wg, 'onTransitionStart'),
+          ze(Fg, 'onTransitionCancel'),
+          ze(Ao, 'onTransitionEnd'),
+          Ha('onMouseEnter', ['mouseout', 'mouseover']),
+          Ha('onMouseLeave', ['mouseout', 'mouseover']),
+          Ha('onPointerEnter', ['pointerout', 'pointerover']),
+          Ha('onPointerLeave', ['pointerout', 'pointerover']),
+          la(
+            'onChange',
+            'change click focusin focusout input keydown keyup selectionchange'.split(
+              ' ',
+            ),
+          ),
+          la(
+            'onSelect',
+            'focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange'.split(
+              ' ',
+            ),
+          ),
+          la('onBeforeInput', [
+            'compositionend',
+            'keypress',
+            'textInput',
+            'paste',
+          ]),
+          la(
+            'onCompositionEnd',
+            'compositionend focusout keydown keypress keyup mousedown'.split(
+              ' ',
+            ),
+          ),
+          la(
+            'onCompositionStart',
+            'compositionstart focusout keydown keypress keyup mousedown'.split(
+              ' ',
+            ),
+          ),
+          la(
+            'onCompositionUpdate',
+            'compositionupdate focusout keydown keypress keyup mousedown'.split(
+              ' ',
+            ),
+          ))
+        var ii =
+            'abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting'.split(
+              ' ',
+            ),
+          jm = new Set(
+            'beforetoggle cancel close invalid load scroll scrollend toggle'
+              .split(' ')
+              .concat(ii),
+          )
+        function Ud(t, e) {
+          e = (e & 4) !== 0
+          for (var n = 0; n < t.length; n++) {
+            var a = t[n],
+              l = a.event
+            a = a.listeners
+            t: {
+              var s = void 0
+              if (e)
+                for (var h = a.length - 1; 0 <= h; h--) {
+                  var g = a[h],
+                    S = g.instance,
+                    B = g.currentTarget
+                  if (((g = g.listener), S !== s && l.isPropagationStopped()))
+                    break t
+                  ;((s = g), (l.currentTarget = B))
+                  try {
+                    s(l)
+                  } catch (X) {
+                    Au(X)
+                  }
+                  ;((l.currentTarget = null), (s = S))
+                }
+              else
+                for (h = 0; h < a.length; h++) {
+                  if (
+                    ((g = a[h]),
+                    (S = g.instance),
+                    (B = g.currentTarget),
+                    (g = g.listener),
+                    S !== s && l.isPropagationStopped())
+                  )
+                    break t
+                  ;((s = g), (l.currentTarget = B))
+                  try {
+                    s(l)
+                  } catch (X) {
+                    Au(X)
+                  }
+                  ;((l.currentTarget = null), (s = S))
+                }
+            }
+          }
+        }
+        function yt(t, e) {
+          var n = e[dc]
+          n === void 0 && (n = e[dc] = new Set())
+          var a = t + '__bubble'
+          n.has(a) || (Qd(e, t, 2, !1), n.add(a))
+        }
+        function tf(t, e, n) {
+          var a = 0
+          ;(e && (a |= 4), Qd(n, t, a, e))
+        }
+        var Mu = '_reactListening' + Math.random().toString(36).slice(2)
+        function ef(t) {
+          if (!t[Mu]) {
+            ;((t[Mu] = !0),
+              Dr.forEach(function (n) {
+                n !== 'selectionchange' &&
+                  (jm.has(n) || tf(n, !1, t), tf(n, !0, t))
+              }))
+            var e = t.nodeType === 9 ? t : t.ownerDocument
+            e === null || e[Mu] || ((e[Mu] = !0), tf('selectionchange', !1, e))
+          }
+        }
+        function Qd(t, e, n, a) {
+          switch (u1(e)) {
+            case 2:
+              var l = lA
+              break
+            case 8:
+              l = iA
+              break
+            default:
+              l = Af
+          }
+          ;((n = l.bind(null, e, n, t)),
+            (l = void 0),
+            !Sc ||
+              (e !== 'touchstart' && e !== 'touchmove' && e !== 'wheel') ||
+              (l = !0),
+            a
+              ? l !== void 0
+                ? t.addEventListener(e, n, { capture: !0, passive: l })
+                : t.addEventListener(e, n, !0)
+              : l !== void 0
+                ? t.addEventListener(e, n, { passive: l })
+                : t.addEventListener(e, n, !1))
+        }
+        function nf(t, e, n, a, l) {
+          var s = a
+          if ((e & 1) === 0 && (e & 2) === 0 && a !== null)
+            t: for (;;) {
+              if (a === null) return
+              var h = a.tag
+              if (h === 3 || h === 4) {
+                var g = a.stateNode.containerInfo
+                if (g === l) break
+                if (h === 4)
+                  for (h = a.return; h !== null; ) {
+                    var S = h.tag
+                    if ((S === 3 || S === 4) && h.stateNode.containerInfo === l)
+                      return
+                    h = h.return
+                  }
+                for (; g !== null; ) {
+                  if (((h = Ca(g)), h === null)) return
+                  if (
+                    ((S = h.tag), S === 5 || S === 6 || S === 26 || S === 27)
+                  ) {
+                    a = s = h
+                    continue t
+                  }
+                  g = g.parentNode
+                }
+              }
+              a = a.return
+            }
+          Vr(function () {
+            var B = s,
+              X = pc(n),
+              k = []
+            t: {
+              var Q = vo.get(t)
+              if (Q !== void 0) {
+                var Y = Zi,
+                  rt = t
+                switch (t) {
+                  case 'keypress':
+                    if (Vi(n) === 0) break t
+                  case 'keydown':
+                  case 'keyup':
+                    Y = wg
+                    break
+                  case 'focusin':
+                    ;((rt = 'focus'), (Y = Oc))
+                    break
+                  case 'focusout':
+                    ;((rt = 'blur'), (Y = Oc))
+                    break
+                  case 'beforeblur':
+                  case 'afterblur':
+                    Y = Oc
+                    break
+                  case 'click':
+                    if (n.button === 2) break t
+                  case 'auxclick':
+                  case 'dblclick':
+                  case 'mousedown':
+                  case 'mousemove':
+                  case 'mouseup':
+                  case 'mouseout':
+                  case 'mouseover':
+                  case 'contextmenu':
+                    Y = qr
+                    break
+                  case 'drag':
+                  case 'dragend':
+                  case 'dragenter':
+                  case 'dragexit':
+                  case 'dragleave':
+                  case 'dragover':
+                  case 'dragstart':
+                  case 'drop':
+                    Y = hg
+                    break
+                  case 'touchcancel':
+                  case 'touchend':
+                  case 'touchmove':
+                  case 'touchstart':
+                    Y = Dg
+                    break
+                  case ho:
+                  case go:
+                  case mo:
+                    Y = Ag
+                    break
+                  case Ao:
+                    Y = Mg
+                    break
+                  case 'scroll':
+                  case 'scrollend':
+                    Y = og
+                    break
+                  case 'wheel':
+                    Y = Hg
+                    break
+                  case 'copy':
+                  case 'cut':
+                  case 'paste':
+                    Y = yg
+                    break
+                  case 'gotpointercapture':
+                  case 'lostpointercapture':
+                  case 'pointercancel':
+                  case 'pointerdown':
+                  case 'pointermove':
+                  case 'pointerout':
+                  case 'pointerover':
+                  case 'pointerup':
+                    Y = Kr
+                    break
+                  case 'toggle':
+                  case 'beforetoggle':
+                    Y = Bg
+                }
+                var st = (e & 4) !== 0,
+                  Ot = !st && (t === 'scroll' || t === 'scrollend'),
+                  C = st ? (Q !== null ? Q + 'Capture' : null) : Q
+                st = []
+                for (var O = B, H; O !== null; ) {
+                  var Z = O
+                  if (
+                    ((H = Z.stateNode),
+                    (Z = Z.tag),
+                    (Z !== 5 && Z !== 26 && Z !== 27) ||
+                      H === null ||
+                      C === null ||
+                      ((Z = Tl(O, C)), Z != null && st.push(ui(O, Z, H))),
+                    Ot)
+                  )
+                    break
+                  O = O.return
+                }
+                0 < st.length &&
+                  ((Q = new Y(Q, rt, null, n, X)),
+                  k.push({ event: Q, listeners: st }))
+              }
+            }
+            if ((e & 7) === 0) {
+              t: {
+                if (
+                  ((Q = t === 'mouseover' || t === 'pointerover'),
+                  (Y = t === 'mouseout' || t === 'pointerout'),
+                  Q &&
+                    n !== bc &&
+                    (rt = n.relatedTarget || n.fromElement) &&
+                    (Ca(rt) || rt[Da]))
+                )
+                  break t
+                if (
+                  (Y || Q) &&
+                  ((Q =
+                    X.window === X
+                      ? X
+                      : (Q = X.ownerDocument)
+                        ? Q.defaultView || Q.parentWindow
+                        : window),
+                  Y
+                    ? ((rt = n.relatedTarget || n.toElement),
+                      (Y = B),
+                      (rt = rt ? Ca(rt) : null),
+                      rt !== null &&
+                        ((Ot = o(rt)),
+                        (st = rt.tag),
+                        rt !== Ot || (st !== 5 && st !== 27 && st !== 6)) &&
+                        (rt = null))
+                    : ((Y = null), (rt = B)),
+                  Y !== rt)
+                ) {
+                  if (
+                    ((st = qr),
+                    (Z = 'onMouseLeave'),
+                    (C = 'onMouseEnter'),
+                    (O = 'mouse'),
+                    (t === 'pointerout' || t === 'pointerover') &&
+                      ((st = Kr),
+                      (Z = 'onPointerLeave'),
+                      (C = 'onPointerEnter'),
+                      (O = 'pointer')),
+                    (Ot = Y == null ? Q : Sl(Y)),
+                    (H = rt == null ? Q : Sl(rt)),
+                    (Q = new st(Z, O + 'leave', Y, n, X)),
+                    (Q.target = Ot),
+                    (Q.relatedTarget = H),
+                    (Z = null),
+                    Ca(X) === B &&
+                      ((st = new st(C, O + 'enter', rt, n, X)),
+                      (st.target = H),
+                      (st.relatedTarget = Ot),
+                      (Z = st)),
+                    (Ot = Z),
+                    Y && rt)
+                  )
+                    e: {
+                      for (st = Y, C = rt, O = 0, H = st; H; H = fl(H)) O++
+                      for (H = 0, Z = C; Z; Z = fl(Z)) H++
+                      for (; 0 < O - H; ) ((st = fl(st)), O--)
+                      for (; 0 < H - O; ) ((C = fl(C)), H--)
+                      for (; O--; ) {
+                        if (st === C || (C !== null && st === C.alternate))
+                          break e
+                        ;((st = fl(st)), (C = fl(C)))
+                      }
+                      st = null
+                    }
+                  else st = null
+                  ;(Y !== null && Yd(k, Q, Y, st, !1),
+                    rt !== null && Ot !== null && Yd(k, Ot, rt, st, !0))
+                }
+              }
+              t: {
+                if (
+                  ((Q = B ? Sl(B) : window),
+                  (Y = Q.nodeName && Q.nodeName.toLowerCase()),
+                  Y === 'select' || (Y === 'input' && Q.type === 'file'))
+                )
+                  var nt = eo
+                else if ($r(Q))
+                  if (no) nt = Zg
+                  else {
+                    nt = Vg
+                    var At = Xg
+                  }
+                else
+                  ((Y = Q.nodeName),
+                    !Y ||
+                    Y.toLowerCase() !== 'input' ||
+                    (Q.type !== 'checkbox' && Q.type !== 'radio')
+                      ? B && Ec(B.elementType) && (nt = eo)
+                      : (nt = Ig))
+                if (nt && (nt = nt(t, B))) {
+                  to(k, nt, n, X)
+                  break t
+                }
+                ;(At && At(t, Q, B),
+                  t === 'focusout' &&
+                    B &&
+                    Q.type === 'number' &&
+                    B.memoizedProps.value != null &&
+                    yc(Q, 'number', Q.value))
+              }
+              switch (((At = B ? Sl(B) : window), t)) {
+                case 'focusin':
+                  ;($r(At) || At.contentEditable === 'true') &&
+                    ((za = At), (Nc = B), (Hl = null))
+                  break
+                case 'focusout':
+                  Hl = Nc = za = null
+                  break
+                case 'mousedown':
+                  Bc = !0
+                  break
+                case 'contextmenu':
+                case 'mouseup':
+                case 'dragend':
+                  ;((Bc = !1), ro(k, n, X))
+                  break
+                case 'selectionchange':
+                  if (kg) break
+                case 'keydown':
+                case 'keyup':
+                  ro(k, n, X)
+              }
+              var lt
+              if (Cc)
+                t: {
+                  switch (t) {
+                    case 'compositionstart':
+                      var ft = 'onCompositionStart'
+                      break t
+                    case 'compositionend':
+                      ft = 'onCompositionEnd'
+                      break t
+                    case 'compositionupdate':
+                      ft = 'onCompositionUpdate'
+                      break t
+                  }
+                  ft = void 0
+                }
+              else
+                La
+                  ? Pr(t, n) && (ft = 'onCompositionEnd')
+                  : t === 'keydown' &&
+                    n.keyCode === 229 &&
+                    (ft = 'onCompositionStart')
+              ;(ft &&
+                (Wr &&
+                  n.locale !== 'ko' &&
+                  (La || ft !== 'onCompositionStart'
+                    ? ft === 'onCompositionEnd' && La && (lt = Ir())
+                    : ((Sn = X),
+                      (Tc = 'value' in Sn ? Sn.value : Sn.textContent),
+                      (La = !0))),
+                (At = ju(B, ft)),
+                0 < At.length &&
+                  ((ft = new kr(ft, t, null, n, X)),
+                  k.push({ event: ft, listeners: At }),
+                  lt
+                    ? (ft.data = lt)
+                    : ((lt = _r(n)), lt !== null && (ft.data = lt)))),
+                (lt = Qg ? Yg(t, n) : Lg(t, n)) &&
+                  ((ft = ju(B, 'onBeforeInput')),
+                  0 < ft.length &&
+                    ((At = new kr('onBeforeInput', 'beforeinput', null, n, X)),
+                    k.push({ event: At, listeners: ft }),
+                    (At.data = lt))),
+                Dm(k, t, B, n, X))
+            }
+            Ud(k, e)
+          })
+        }
+        function ui(t, e, n) {
+          return { instance: t, listener: e, currentTarget: n }
+        }
+        function ju(t, e) {
+          for (var n = e + 'Capture', a = []; t !== null; ) {
+            var l = t,
+              s = l.stateNode
+            if (
+              ((l = l.tag),
+              (l !== 5 && l !== 26 && l !== 27) ||
+                s === null ||
+                ((l = Tl(t, n)),
+                l != null && a.unshift(ui(t, l, s)),
+                (l = Tl(t, e)),
+                l != null && a.push(ui(t, l, s))),
+              t.tag === 3)
+            )
+              return a
+            t = t.return
+          }
+          return []
+        }
+        function fl(t) {
+          if (t === null) return null
+          do t = t.return
+          while (t && t.tag !== 5 && t.tag !== 27)
+          return t || null
+        }
+        function Yd(t, e, n, a, l) {
+          for (var s = e._reactName, h = []; n !== null && n !== a; ) {
+            var g = n,
+              S = g.alternate,
+              B = g.stateNode
+            if (((g = g.tag), S !== null && S === a)) break
+            ;((g !== 5 && g !== 26 && g !== 27) ||
+              B === null ||
+              ((S = B),
+              l
+                ? ((B = Tl(n, s)), B != null && h.unshift(ui(n, B, S)))
+                : l || ((B = Tl(n, s)), B != null && h.push(ui(n, B, S)))),
+              (n = n.return))
+          }
+          h.length !== 0 && t.push({ event: e, listeners: h })
+        }
+        var Hm = /\r\n?/g,
+          Nm = /\u0000|\uFFFD/g
+        function Ld(t) {
+          return (typeof t == 'string' ? t : '' + t)
+            .replace(
+              Hm,
+              `
+`,
+            )
+            .replace(Nm, '')
+        }
+        function zd(t, e) {
+          return ((e = Ld(e)), Ld(t) === e)
+        }
+        function Hu() {}
+        function Rt(t, e, n, a, l, s) {
+          switch (n) {
+            case 'children':
+              typeof a == 'string'
+                ? e === 'body' || (e === 'textarea' && a === '') || Ua(t, a)
+                : (typeof a == 'number' || typeof a == 'bigint') &&
+                  e !== 'body' &&
+                  Ua(t, '' + a)
+              break
+            case 'className':
+              Yi(t, 'class', a)
+              break
+            case 'tabIndex':
+              Yi(t, 'tabindex', a)
+              break
+            case 'dir':
+            case 'role':
+            case 'viewBox':
+            case 'width':
+            case 'height':
+              Yi(t, n, a)
+              break
+            case 'style':
+              Gr(t, a, s)
+              break
+            case 'data':
+              if (e !== 'object') {
+                Yi(t, 'data', a)
+                break
+              }
+            case 'src':
+            case 'href':
+              if (a === '' && (e !== 'a' || n !== 'href')) {
+                t.removeAttribute(n)
+                break
+              }
+              if (
+                a == null ||
+                typeof a == 'function' ||
+                typeof a == 'symbol' ||
+                typeof a == 'boolean'
+              ) {
+                t.removeAttribute(n)
+                break
+              }
+              ;((a = Gi('' + a)), t.setAttribute(n, a))
+              break
+            case 'action':
+            case 'formAction':
+              if (typeof a == 'function') {
+                t.setAttribute(
+                  n,
+                  "javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')",
+                )
+                break
+              } else
+                typeof s == 'function' &&
+                  (n === 'formAction'
+                    ? (e !== 'input' && Rt(t, e, 'name', l.name, l, null),
+                      Rt(t, e, 'formEncType', l.formEncType, l, null),
+                      Rt(t, e, 'formMethod', l.formMethod, l, null),
+                      Rt(t, e, 'formTarget', l.formTarget, l, null))
+                    : (Rt(t, e, 'encType', l.encType, l, null),
+                      Rt(t, e, 'method', l.method, l, null),
+                      Rt(t, e, 'target', l.target, l, null)))
+              if (a == null || typeof a == 'symbol' || typeof a == 'boolean') {
+                t.removeAttribute(n)
+                break
+              }
+              ;((a = Gi('' + a)), t.setAttribute(n, a))
+              break
+            case 'onClick':
+              a != null && (t.onclick = Hu)
+              break
+            case 'onScroll':
+              a != null && yt('scroll', t)
+              break
+            case 'onScrollEnd':
+              a != null && yt('scrollend', t)
+              break
+            case 'dangerouslySetInnerHTML':
+              if (a != null) {
+                if (typeof a != 'object' || !('__html' in a)) throw Error(f(61))
+                if (((n = a.__html), n != null)) {
+                  if (l.children != null) throw Error(f(60))
+                  t.innerHTML = n
+                }
+              }
+              break
+            case 'multiple':
+              t.multiple = a && typeof a != 'function' && typeof a != 'symbol'
+              break
+            case 'muted':
+              t.muted = a && typeof a != 'function' && typeof a != 'symbol'
+              break
+            case 'suppressContentEditableWarning':
+            case 'suppressHydrationWarning':
+            case 'defaultValue':
+            case 'defaultChecked':
+            case 'innerHTML':
+            case 'ref':
+              break
+            case 'autoFocus':
+              break
+            case 'xlinkHref':
+              if (
+                a == null ||
+                typeof a == 'function' ||
+                typeof a == 'boolean' ||
+                typeof a == 'symbol'
+              ) {
+                t.removeAttribute('xlink:href')
+                break
+              }
+              ;((n = Gi('' + a)),
+                t.setAttributeNS(
+                  'http://www.w3.org/1999/xlink',
+                  'xlink:href',
+                  n,
+                ))
+              break
+            case 'contentEditable':
+            case 'spellCheck':
+            case 'draggable':
+            case 'value':
+            case 'autoReverse':
+            case 'externalResourcesRequired':
+            case 'focusable':
+            case 'preserveAlpha':
+              a != null && typeof a != 'function' && typeof a != 'symbol'
+                ? t.setAttribute(n, '' + a)
+                : t.removeAttribute(n)
+              break
+            case 'inert':
+            case 'allowFullScreen':
+            case 'async':
+            case 'autoPlay':
+            case 'controls':
+            case 'default':
+            case 'defer':
+            case 'disabled':
+            case 'disablePictureInPicture':
+            case 'disableRemotePlayback':
+            case 'formNoValidate':
+            case 'hidden':
+            case 'loop':
+            case 'noModule':
+            case 'noValidate':
+            case 'open':
+            case 'playsInline':
+            case 'readOnly':
+            case 'required':
+            case 'reversed':
+            case 'scoped':
+            case 'seamless':
+            case 'itemScope':
+              a && typeof a != 'function' && typeof a != 'symbol'
+                ? t.setAttribute(n, '')
+                : t.removeAttribute(n)
+              break
+            case 'capture':
+            case 'download':
+              a === !0
+                ? t.setAttribute(n, '')
+                : a !== !1 &&
+                    a != null &&
+                    typeof a != 'function' &&
+                    typeof a != 'symbol'
+                  ? t.setAttribute(n, a)
+                  : t.removeAttribute(n)
+              break
+            case 'cols':
+            case 'rows':
+            case 'size':
+            case 'span':
+              a != null &&
+              typeof a != 'function' &&
+              typeof a != 'symbol' &&
+              !isNaN(a) &&
+              1 <= a
+                ? t.setAttribute(n, a)
+                : t.removeAttribute(n)
+              break
+            case 'rowSpan':
+            case 'start':
+              a == null ||
+              typeof a == 'function' ||
+              typeof a == 'symbol' ||
+              isNaN(a)
+                ? t.removeAttribute(n)
+                : t.setAttribute(n, a)
+              break
+            case 'popover':
+              ;(yt('beforetoggle', t), yt('toggle', t), Qi(t, 'popover', a))
+              break
+            case 'xlinkActuate':
+              Je(t, 'http://www.w3.org/1999/xlink', 'xlink:actuate', a)
+              break
+            case 'xlinkArcrole':
+              Je(t, 'http://www.w3.org/1999/xlink', 'xlink:arcrole', a)
+              break
+            case 'xlinkRole':
+              Je(t, 'http://www.w3.org/1999/xlink', 'xlink:role', a)
+              break
+            case 'xlinkShow':
+              Je(t, 'http://www.w3.org/1999/xlink', 'xlink:show', a)
+              break
+            case 'xlinkTitle':
+              Je(t, 'http://www.w3.org/1999/xlink', 'xlink:title', a)
+              break
+            case 'xlinkType':
+              Je(t, 'http://www.w3.org/1999/xlink', 'xlink:type', a)
+              break
+            case 'xmlBase':
+              Je(t, 'http://www.w3.org/XML/1998/namespace', 'xml:base', a)
+              break
+            case 'xmlLang':
+              Je(t, 'http://www.w3.org/XML/1998/namespace', 'xml:lang', a)
+              break
+            case 'xmlSpace':
+              Je(t, 'http://www.w3.org/XML/1998/namespace', 'xml:space', a)
+              break
+            case 'is':
+              Qi(t, 'is', a)
+              break
+            case 'innerText':
+            case 'textContent':
+              break
+            default:
+              ;(!(2 < n.length) ||
+                (n[0] !== 'o' && n[0] !== 'O') ||
+                (n[1] !== 'n' && n[1] !== 'N')) &&
+                ((n = fg.get(n) || n), Qi(t, n, a))
+          }
+        }
+        function af(t, e, n, a, l, s) {
+          switch (n) {
+            case 'style':
+              Gr(t, a, s)
+              break
+            case 'dangerouslySetInnerHTML':
+              if (a != null) {
+                if (typeof a != 'object' || !('__html' in a)) throw Error(f(61))
+                if (((n = a.__html), n != null)) {
+                  if (l.children != null) throw Error(f(60))
+                  t.innerHTML = n
+                }
+              }
+              break
+            case 'children':
+              typeof a == 'string'
+                ? Ua(t, a)
+                : (typeof a == 'number' || typeof a == 'bigint') &&
+                  Ua(t, '' + a)
+              break
+            case 'onScroll':
+              a != null && yt('scroll', t)
+              break
+            case 'onScrollEnd':
+              a != null && yt('scrollend', t)
+              break
+            case 'onClick':
+              a != null && (t.onclick = Hu)
+              break
+            case 'suppressContentEditableWarning':
+            case 'suppressHydrationWarning':
+            case 'innerHTML':
+            case 'ref':
+              break
+            case 'innerText':
+            case 'textContent':
+              break
+            default:
+              if (!Cr.hasOwnProperty(n))
+                t: {
+                  if (
+                    n[0] === 'o' &&
+                    n[1] === 'n' &&
+                    ((l = n.endsWith('Capture')),
+                    (e = n.slice(2, l ? n.length - 7 : void 0)),
+                    (s = t[re] || null),
+                    (s = s != null ? s[n] : null),
+                    typeof s == 'function' && t.removeEventListener(e, s, l),
+                    typeof a == 'function')
+                  ) {
+                    ;(typeof s != 'function' &&
+                      s !== null &&
+                      (n in t
+                        ? (t[n] = null)
+                        : t.hasAttribute(n) && t.removeAttribute(n)),
+                      t.addEventListener(e, a, l))
+                    break t
+                  }
+                  n in t
+                    ? (t[n] = a)
+                    : a === !0
+                      ? t.setAttribute(n, '')
+                      : Qi(t, n, a)
+                }
+          }
+        }
+        function te(t, e, n) {
+          switch (e) {
+            case 'div':
+            case 'span':
+            case 'svg':
+            case 'path':
+            case 'a':
+            case 'g':
+            case 'p':
+            case 'li':
+              break
+            case 'img':
+              ;(yt('error', t), yt('load', t))
+              var a = !1,
+                l = !1,
+                s
+              for (s in n)
+                if (n.hasOwnProperty(s)) {
+                  var h = n[s]
+                  if (h != null)
+                    switch (s) {
+                      case 'src':
+                        a = !0
+                        break
+                      case 'srcSet':
+                        l = !0
+                        break
+                      case 'children':
+                      case 'dangerouslySetInnerHTML':
+                        throw Error(f(137, e))
+                      default:
+                        Rt(t, e, s, h, n, null)
+                    }
+                }
+              ;(l && Rt(t, e, 'srcSet', n.srcSet, n, null),
+                a && Rt(t, e, 'src', n.src, n, null))
+              return
+            case 'input':
+              yt('invalid', t)
+              var g = (s = h = l = null),
+                S = null,
+                B = null
+              for (a in n)
+                if (n.hasOwnProperty(a)) {
+                  var X = n[a]
+                  if (X != null)
+                    switch (a) {
+                      case 'name':
+                        l = X
+                        break
+                      case 'type':
+                        h = X
+                        break
+                      case 'checked':
+                        S = X
+                        break
+                      case 'defaultChecked':
+                        B = X
+                        break
+                      case 'value':
+                        s = X
+                        break
+                      case 'defaultValue':
+                        g = X
+                        break
+                      case 'children':
+                      case 'dangerouslySetInnerHTML':
+                        if (X != null) throw Error(f(137, e))
+                        break
+                      default:
+                        Rt(t, e, a, X, n, null)
+                    }
+                }
+              ;(Qr(t, s, g, S, B, h, l, !1), Li(t))
+              return
+            case 'select':
+              ;(yt('invalid', t), (a = h = s = null))
+              for (l in n)
+                if (n.hasOwnProperty(l) && ((g = n[l]), g != null))
+                  switch (l) {
+                    case 'value':
+                      s = g
+                      break
+                    case 'defaultValue':
+                      h = g
+                      break
+                    case 'multiple':
+                      a = g
+                    default:
+                      Rt(t, e, l, g, n, null)
+                  }
+              ;((e = s),
+                (n = h),
+                (t.multiple = !!a),
+                e != null ? Ba(t, !!a, e, !1) : n != null && Ba(t, !!a, n, !0))
+              return
+            case 'textarea':
+              ;(yt('invalid', t), (s = l = a = null))
+              for (h in n)
+                if (n.hasOwnProperty(h) && ((g = n[h]), g != null))
+                  switch (h) {
+                    case 'value':
+                      a = g
+                      break
+                    case 'defaultValue':
+                      l = g
+                      break
+                    case 'children':
+                      s = g
+                      break
+                    case 'dangerouslySetInnerHTML':
+                      if (g != null) throw Error(f(91))
+                      break
+                    default:
+                      Rt(t, e, h, g, n, null)
+                  }
+              ;(Lr(t, a, l, s), Li(t))
+              return
+            case 'option':
+              for (S in n)
+                if (n.hasOwnProperty(S) && ((a = n[S]), a != null))
+                  switch (S) {
+                    case 'selected':
+                      t.selected =
+                        a && typeof a != 'function' && typeof a != 'symbol'
+                      break
+                    default:
+                      Rt(t, e, S, a, n, null)
+                  }
+              return
+            case 'dialog':
+              ;(yt('beforetoggle', t),
+                yt('toggle', t),
+                yt('cancel', t),
+                yt('close', t))
+              break
+            case 'iframe':
+            case 'object':
+              yt('load', t)
+              break
+            case 'video':
+            case 'audio':
+              for (a = 0; a < ii.length; a++) yt(ii[a], t)
+              break
+            case 'image':
+              ;(yt('error', t), yt('load', t))
+              break
+            case 'details':
+              yt('toggle', t)
+              break
+            case 'embed':
+            case 'source':
+            case 'link':
+              ;(yt('error', t), yt('load', t))
+            case 'area':
+            case 'base':
+            case 'br':
+            case 'col':
+            case 'hr':
+            case 'keygen':
+            case 'meta':
+            case 'param':
+            case 'track':
+            case 'wbr':
+            case 'menuitem':
+              for (B in n)
+                if (n.hasOwnProperty(B) && ((a = n[B]), a != null))
+                  switch (B) {
+                    case 'children':
+                    case 'dangerouslySetInnerHTML':
+                      throw Error(f(137, e))
+                    default:
+                      Rt(t, e, B, a, n, null)
+                  }
+              return
+            default:
+              if (Ec(e)) {
+                for (X in n)
+                  n.hasOwnProperty(X) &&
+                    ((a = n[X]), a !== void 0 && af(t, e, X, a, n, void 0))
+                return
+              }
+          }
+          for (g in n)
+            n.hasOwnProperty(g) &&
+              ((a = n[g]), a != null && Rt(t, e, g, a, n, null))
+        }
+        function Bm(t, e, n, a) {
+          switch (e) {
+            case 'div':
+            case 'span':
+            case 'svg':
+            case 'path':
+            case 'a':
+            case 'g':
+            case 'p':
+            case 'li':
+              break
+            case 'input':
+              var l = null,
+                s = null,
+                h = null,
+                g = null,
+                S = null,
+                B = null,
+                X = null
+              for (Y in n) {
+                var k = n[Y]
+                if (n.hasOwnProperty(Y) && k != null)
+                  switch (Y) {
+                    case 'checked':
+                      break
+                    case 'value':
+                      break
+                    case 'defaultValue':
+                      S = k
+                    default:
+                      a.hasOwnProperty(Y) || Rt(t, e, Y, null, a, k)
+                  }
+              }
+              for (var Q in a) {
+                var Y = a[Q]
+                if (
+                  ((k = n[Q]), a.hasOwnProperty(Q) && (Y != null || k != null))
+                )
+                  switch (Q) {
+                    case 'type':
+                      s = Y
+                      break
+                    case 'name':
+                      l = Y
+                      break
+                    case 'checked':
+                      B = Y
+                      break
+                    case 'defaultChecked':
+                      X = Y
+                      break
+                    case 'value':
+                      h = Y
+                      break
+                    case 'defaultValue':
+                      g = Y
+                      break
+                    case 'children':
+                    case 'dangerouslySetInnerHTML':
+                      if (Y != null) throw Error(f(137, e))
+                      break
+                    default:
+                      Y !== k && Rt(t, e, Q, Y, a, k)
+                  }
+              }
+              vc(t, h, g, S, B, X, s, l)
+              return
+            case 'select':
+              Y = h = g = Q = null
+              for (s in n)
+                if (((S = n[s]), n.hasOwnProperty(s) && S != null))
+                  switch (s) {
+                    case 'value':
+                      break
+                    case 'multiple':
+                      Y = S
+                    default:
+                      a.hasOwnProperty(s) || Rt(t, e, s, null, a, S)
+                  }
+              for (l in a)
+                if (
+                  ((s = a[l]),
+                  (S = n[l]),
+                  a.hasOwnProperty(l) && (s != null || S != null))
+                )
+                  switch (l) {
+                    case 'value':
+                      Q = s
+                      break
+                    case 'defaultValue':
+                      g = s
+                      break
+                    case 'multiple':
+                      h = s
+                    default:
+                      s !== S && Rt(t, e, l, s, a, S)
+                  }
+              ;((e = g),
+                (n = h),
+                (a = Y),
+                Q != null
+                  ? Ba(t, !!n, Q, !1)
+                  : !!a != !!n &&
+                    (e != null
+                      ? Ba(t, !!n, e, !0)
+                      : Ba(t, !!n, n ? [] : '', !1)))
+              return
+            case 'textarea':
+              Y = Q = null
+              for (g in n)
+                if (
+                  ((l = n[g]),
+                  n.hasOwnProperty(g) && l != null && !a.hasOwnProperty(g))
+                )
+                  switch (g) {
+                    case 'value':
+                      break
+                    case 'children':
+                      break
+                    default:
+                      Rt(t, e, g, null, a, l)
+                  }
+              for (h in a)
+                if (
+                  ((l = a[h]),
+                  (s = n[h]),
+                  a.hasOwnProperty(h) && (l != null || s != null))
+                )
+                  switch (h) {
+                    case 'value':
+                      Q = l
+                      break
+                    case 'defaultValue':
+                      Y = l
+                      break
+                    case 'children':
+                      break
+                    case 'dangerouslySetInnerHTML':
+                      if (l != null) throw Error(f(91))
+                      break
+                    default:
+                      l !== s && Rt(t, e, h, l, a, s)
+                  }
+              Yr(t, Q, Y)
+              return
+            case 'option':
+              for (var rt in n)
+                if (
+                  ((Q = n[rt]),
+                  n.hasOwnProperty(rt) && Q != null && !a.hasOwnProperty(rt))
+                )
+                  switch (rt) {
+                    case 'selected':
+                      t.selected = !1
+                      break
+                    default:
+                      Rt(t, e, rt, null, a, Q)
+                  }
+              for (S in a)
+                if (
+                  ((Q = a[S]),
+                  (Y = n[S]),
+                  a.hasOwnProperty(S) && Q !== Y && (Q != null || Y != null))
+                )
+                  switch (S) {
+                    case 'selected':
+                      t.selected =
+                        Q && typeof Q != 'function' && typeof Q != 'symbol'
+                      break
+                    default:
+                      Rt(t, e, S, Q, a, Y)
+                  }
+              return
+            case 'img':
+            case 'link':
+            case 'area':
+            case 'base':
+            case 'br':
+            case 'col':
+            case 'embed':
+            case 'hr':
+            case 'keygen':
+            case 'meta':
+            case 'param':
+            case 'source':
+            case 'track':
+            case 'wbr':
+            case 'menuitem':
+              for (var st in n)
+                ((Q = n[st]),
+                  n.hasOwnProperty(st) &&
+                    Q != null &&
+                    !a.hasOwnProperty(st) &&
+                    Rt(t, e, st, null, a, Q))
+              for (B in a)
+                if (
+                  ((Q = a[B]),
+                  (Y = n[B]),
+                  a.hasOwnProperty(B) && Q !== Y && (Q != null || Y != null))
+                )
+                  switch (B) {
+                    case 'children':
+                    case 'dangerouslySetInnerHTML':
+                      if (Q != null) throw Error(f(137, e))
+                      break
+                    default:
+                      Rt(t, e, B, Q, a, Y)
+                  }
+              return
+            default:
+              if (Ec(e)) {
+                for (var Ot in n)
+                  ((Q = n[Ot]),
+                    n.hasOwnProperty(Ot) &&
+                      Q !== void 0 &&
+                      !a.hasOwnProperty(Ot) &&
+                      af(t, e, Ot, void 0, a, Q))
+                for (X in a)
+                  ((Q = a[X]),
+                    (Y = n[X]),
+                    !a.hasOwnProperty(X) ||
+                      Q === Y ||
+                      (Q === void 0 && Y === void 0) ||
+                      af(t, e, X, Q, a, Y))
+                return
+              }
+          }
+          for (var C in n)
+            ((Q = n[C]),
+              n.hasOwnProperty(C) &&
+                Q != null &&
+                !a.hasOwnProperty(C) &&
+                Rt(t, e, C, null, a, Q))
+          for (k in a)
+            ((Q = a[k]),
+              (Y = n[k]),
+              !a.hasOwnProperty(k) ||
+                Q === Y ||
+                (Q == null && Y == null) ||
+                Rt(t, e, k, Q, a, Y))
+        }
+        var lf = null,
+          uf = null
+        function Nu(t) {
+          return t.nodeType === 9 ? t : t.ownerDocument
+        }
+        function Gd(t) {
+          switch (t) {
+            case 'http://www.w3.org/2000/svg':
+              return 1
+            case 'http://www.w3.org/1998/Math/MathML':
+              return 2
+            default:
+              return 0
+          }
+        }
+        function Xd(t, e) {
+          if (t === 0)
+            switch (e) {
+              case 'svg':
+                return 1
+              case 'math':
+                return 2
+              default:
+                return 0
+            }
+          return t === 1 && e === 'foreignObject' ? 0 : t
+        }
+        function cf(t, e) {
+          return (
+            t === 'textarea' ||
+            t === 'noscript' ||
+            typeof e.children == 'string' ||
+            typeof e.children == 'number' ||
+            typeof e.children == 'bigint' ||
+            (typeof e.dangerouslySetInnerHTML == 'object' &&
+              e.dangerouslySetInnerHTML !== null &&
+              e.dangerouslySetInnerHTML.__html != null)
+          )
+        }
+        var sf = null
+        function Um() {
+          var t = window.event
+          return t && t.type === 'popstate'
+            ? t === sf
+              ? !1
+              : ((sf = t), !0)
+            : ((sf = null), !1)
+        }
+        var Vd = typeof setTimeout == 'function' ? setTimeout : void 0,
+          Qm = typeof clearTimeout == 'function' ? clearTimeout : void 0,
+          Id = typeof Promise == 'function' ? Promise : void 0,
+          Ym =
+            typeof queueMicrotask == 'function'
+              ? queueMicrotask
+              : typeof Id < 'u'
+                ? function (t) {
+                    return Id.resolve(null).then(t).catch(Lm)
+                  }
+                : Vd
+        function Lm(t) {
+          setTimeout(function () {
+            throw t
+          })
+        }
+        function zn(t) {
+          return t === 'head'
+        }
+        function Zd(t, e) {
+          var n = e,
+            a = 0,
+            l = 0
+          do {
+            var s = n.nextSibling
+            if ((t.removeChild(n), s && s.nodeType === 8))
+              if (((n = s.data), n === '/$')) {
+                if (0 < a && 8 > a) {
+                  n = a
+                  var h = t.ownerDocument
+                  if (
+                    (n & 1 && ci(h.documentElement), n & 2 && ci(h.body), n & 4)
+                  )
+                    for (n = h.head, ci(n), h = n.firstChild; h; ) {
+                      var g = h.nextSibling,
+                        S = h.nodeName
+                      ;(h[xl] ||
+                        S === 'SCRIPT' ||
+                        S === 'STYLE' ||
+                        (S === 'LINK' &&
+                          h.rel.toLowerCase() === 'stylesheet') ||
+                        n.removeChild(h),
+                        (h = g))
+                    }
+                }
+                if (l === 0) {
+                  ;(t.removeChild(s), mi(e))
+                  return
+                }
+                l--
+              } else
+                n === '$' || n === '$?' || n === '$!'
+                  ? l++
+                  : (a = n.charCodeAt(0) - 48)
+            else a = 0
+            n = s
+          } while (n)
+          mi(e)
+        }
+        function ff(t) {
+          var e = t.firstChild
+          for (e && e.nodeType === 10 && (e = e.nextSibling); e; ) {
+            var n = e
+            switch (((e = e.nextSibling), n.nodeName)) {
+              case 'HTML':
+              case 'HEAD':
+              case 'BODY':
+                ;(ff(n), hc(n))
+                continue
+              case 'SCRIPT':
+              case 'STYLE':
+                continue
+              case 'LINK':
+                if (n.rel.toLowerCase() === 'stylesheet') continue
+            }
+            t.removeChild(n)
+          }
+        }
+        function zm(t, e, n, a) {
+          for (; t.nodeType === 1; ) {
+            var l = n
+            if (t.nodeName.toLowerCase() !== e.toLowerCase()) {
+              if (!a && (t.nodeName !== 'INPUT' || t.type !== 'hidden')) break
+            } else if (a) {
+              if (!t[xl])
+                switch (e) {
+                  case 'meta':
+                    if (!t.hasAttribute('itemprop')) break
+                    return t
+                  case 'link':
+                    if (
+                      ((s = t.getAttribute('rel')),
+                      s === 'stylesheet' && t.hasAttribute('data-precedence'))
+                    )
+                      break
+                    if (
+                      s !== l.rel ||
+                      t.getAttribute('href') !==
+                        (l.href == null || l.href === '' ? null : l.href) ||
+                      t.getAttribute('crossorigin') !==
+                        (l.crossOrigin == null ? null : l.crossOrigin) ||
+                      t.getAttribute('title') !==
+                        (l.title == null ? null : l.title)
+                    )
+                      break
+                    return t
+                  case 'style':
+                    if (t.hasAttribute('data-precedence')) break
+                    return t
+                  case 'script':
+                    if (
+                      ((s = t.getAttribute('src')),
+                      (s !== (l.src == null ? null : l.src) ||
+                        t.getAttribute('type') !==
+                          (l.type == null ? null : l.type) ||
+                        t.getAttribute('crossorigin') !==
+                          (l.crossOrigin == null ? null : l.crossOrigin)) &&
+                        s &&
+                        t.hasAttribute('async') &&
+                        !t.hasAttribute('itemprop'))
+                    )
+                      break
+                    return t
+                  default:
+                    return t
+                }
+            } else if (e === 'input' && t.type === 'hidden') {
+              var s = l.name == null ? null : '' + l.name
+              if (l.type === 'hidden' && t.getAttribute('name') === s) return t
+            } else return t
+            if (((t = Xe(t.nextSibling)), t === null)) break
+          }
+          return null
+        }
+        function Gm(t, e, n) {
+          if (e === '') return null
+          for (; t.nodeType !== 3; )
+            if (
+              ((t.nodeType !== 1 ||
+                t.nodeName !== 'INPUT' ||
+                t.type !== 'hidden') &&
+                !n) ||
+              ((t = Xe(t.nextSibling)), t === null)
+            )
+              return null
+          return t
+        }
+        function rf(t) {
+          return (
+            t.data === '$!' ||
+            (t.data === '$?' && t.ownerDocument.readyState === 'complete')
+          )
+        }
+        function Xm(t, e) {
+          var n = t.ownerDocument
+          if (t.data !== '$?' || n.readyState === 'complete') e()
+          else {
+            var a = function () {
+              ;(e(), n.removeEventListener('DOMContentLoaded', a))
+            }
+            ;(n.addEventListener('DOMContentLoaded', a), (t._reactRetry = a))
+          }
+        }
+        function Xe(t) {
+          for (; t != null; t = t.nextSibling) {
+            var e = t.nodeType
+            if (e === 1 || e === 3) break
+            if (e === 8) {
+              if (
+                ((e = t.data),
+                e === '$' ||
+                  e === '$!' ||
+                  e === '$?' ||
+                  e === 'F!' ||
+                  e === 'F')
+              )
+                break
+              if (e === '/$') return null
+            }
+          }
+          return t
+        }
+        var of = null
+        function qd(t) {
+          t = t.previousSibling
+          for (var e = 0; t; ) {
+            if (t.nodeType === 8) {
+              var n = t.data
+              if (n === '$' || n === '$!' || n === '$?') {
+                if (e === 0) return t
+                e--
+              } else n === '/$' && e++
+            }
+            t = t.previousSibling
+          }
+          return null
+        }
+        function kd(t, e, n) {
+          switch (((e = Nu(n)), t)) {
+            case 'html':
+              if (((t = e.documentElement), !t)) throw Error(f(452))
+              return t
+            case 'head':
+              if (((t = e.head), !t)) throw Error(f(453))
+              return t
+            case 'body':
+              if (((t = e.body), !t)) throw Error(f(454))
+              return t
+            default:
+              throw Error(f(451))
+          }
+        }
+        function ci(t) {
+          for (var e = t.attributes; e.length; ) t.removeAttributeNode(e[0])
+          hc(t)
+        }
+        var Be = new Map(),
+          Kd = new Set()
+        function Bu(t) {
+          return typeof t.getRootNode == 'function'
+            ? t.getRootNode()
+            : t.nodeType === 9
+              ? t
+              : t.ownerDocument
+        }
+        var on = _.d
+        _.d = { f: Vm, r: Im, D: Zm, C: qm, L: km, m: Km, X: Fm, S: Wm, M: Jm }
+        function Vm() {
+          var t = on.f(),
+            e = wu()
+          return t || e
+        }
+        function Im(t) {
+          var e = Ma(t)
+          e !== null && e.tag === 5 && e.type === 'form' ? h0(e) : on.r(t)
+        }
+        var rl = typeof document > 'u' ? null : document
+        function Wd(t, e, n) {
+          var a = rl
+          if (a && typeof e == 'string' && e) {
+            var l = Oe(e)
+            ;((l = 'link[rel="' + t + '"][href="' + l + '"]'),
+              typeof n == 'string' && (l += '[crossorigin="' + n + '"]'),
+              Kd.has(l) ||
+                (Kd.add(l),
+                (t = { rel: t, crossOrigin: n, href: e }),
+                a.querySelector(l) === null &&
+                  ((e = a.createElement('link')),
+                  te(e, 'link', t),
+                  kt(e),
+                  a.head.appendChild(e))))
+          }
+        }
+        function Zm(t) {
+          ;(on.D(t), Wd('dns-prefetch', t, null))
+        }
+        function qm(t, e) {
+          ;(on.C(t, e), Wd('preconnect', t, e))
+        }
+        function km(t, e, n) {
+          on.L(t, e, n)
+          var a = rl
+          if (a && t && e) {
+            var l = 'link[rel="preload"][as="' + Oe(e) + '"]'
+            e === 'image' && n && n.imageSrcSet
+              ? ((l += '[imagesrcset="' + Oe(n.imageSrcSet) + '"]'),
+                typeof n.imageSizes == 'string' &&
+                  (l += '[imagesizes="' + Oe(n.imageSizes) + '"]'))
+              : (l += '[href="' + Oe(t) + '"]')
+            var s = l
+            switch (e) {
+              case 'style':
+                s = ol(t)
+                break
+              case 'script':
+                s = dl(t)
+            }
+            Be.has(s) ||
+              ((t = E(
+                {
+                  rel: 'preload',
+                  href: e === 'image' && n && n.imageSrcSet ? void 0 : t,
+                  as: e,
+                },
+                n,
+              )),
+              Be.set(s, t),
+              a.querySelector(l) !== null ||
+                (e === 'style' && a.querySelector(si(s))) ||
+                (e === 'script' && a.querySelector(fi(s))) ||
+                ((e = a.createElement('link')),
+                te(e, 'link', t),
+                kt(e),
+                a.head.appendChild(e)))
+          }
+        }
+        function Km(t, e) {
+          on.m(t, e)
+          var n = rl
+          if (n && t) {
+            var a = e && typeof e.as == 'string' ? e.as : 'script',
+              l =
+                'link[rel="modulepreload"][as="' +
+                Oe(a) +
+                '"][href="' +
+                Oe(t) +
+                '"]',
+              s = l
+            switch (a) {
+              case 'audioworklet':
+              case 'paintworklet':
+              case 'serviceworker':
+              case 'sharedworker':
+              case 'worker':
+              case 'script':
+                s = dl(t)
+            }
+            if (
+              !Be.has(s) &&
+              ((t = E({ rel: 'modulepreload', href: t }, e)),
+              Be.set(s, t),
+              n.querySelector(l) === null)
+            ) {
+              switch (a) {
+                case 'audioworklet':
+                case 'paintworklet':
+                case 'serviceworker':
+                case 'sharedworker':
+                case 'worker':
+                case 'script':
+                  if (n.querySelector(fi(s))) return
+              }
+              ;((a = n.createElement('link')),
+                te(a, 'link', t),
+                kt(a),
+                n.head.appendChild(a))
+            }
+          }
+        }
+        function Wm(t, e, n) {
+          on.S(t, e, n)
+          var a = rl
+          if (a && t) {
+            var l = ja(a).hoistableStyles,
+              s = ol(t)
+            e = e || 'default'
+            var h = l.get(s)
+            if (!h) {
+              var g = { loading: 0, preload: null }
+              if ((h = a.querySelector(si(s)))) g.loading = 5
+              else {
+                ;((t = E(
+                  { rel: 'stylesheet', href: t, 'data-precedence': e },
+                  n,
+                )),
+                  (n = Be.get(s)) && df(t, n))
+                var S = (h = a.createElement('link'))
+                ;(kt(S),
+                  te(S, 'link', t),
+                  (S._p = new Promise(function (B, X) {
+                    ;((S.onload = B), (S.onerror = X))
+                  })),
+                  S.addEventListener('load', function () {
+                    g.loading |= 1
+                  }),
+                  S.addEventListener('error', function () {
+                    g.loading |= 2
+                  }),
+                  (g.loading |= 4),
+                  Uu(h, e, a))
+              }
+              ;((h = { type: 'stylesheet', instance: h, count: 1, state: g }),
+                l.set(s, h))
+            }
+          }
+        }
+        function Fm(t, e) {
+          on.X(t, e)
+          var n = rl
+          if (n && t) {
+            var a = ja(n).hoistableScripts,
+              l = dl(t),
+              s = a.get(l)
+            s ||
+              ((s = n.querySelector(fi(l))),
+              s ||
+                ((t = E({ src: t, async: !0 }, e)),
+                (e = Be.get(l)) && hf(t, e),
+                (s = n.createElement('script')),
+                kt(s),
+                te(s, 'link', t),
+                n.head.appendChild(s)),
+              (s = { type: 'script', instance: s, count: 1, state: null }),
+              a.set(l, s))
+          }
+        }
+        function Jm(t, e) {
+          on.M(t, e)
+          var n = rl
+          if (n && t) {
+            var a = ja(n).hoistableScripts,
+              l = dl(t),
+              s = a.get(l)
+            s ||
+              ((s = n.querySelector(fi(l))),
+              s ||
+                ((t = E({ src: t, async: !0, type: 'module' }, e)),
+                (e = Be.get(l)) && hf(t, e),
+                (s = n.createElement('script')),
+                kt(s),
+                te(s, 'link', t),
+                n.head.appendChild(s)),
+              (s = { type: 'script', instance: s, count: 1, state: null }),
+              a.set(l, s))
+          }
+        }
+        function Fd(t, e, n, a) {
+          var l = (l = ut.current) ? Bu(l) : null
+          if (!l) throw Error(f(446))
+          switch (t) {
+            case 'meta':
+            case 'title':
+              return null
+            case 'style':
+              return typeof n.precedence == 'string' &&
+                typeof n.href == 'string'
+                ? ((e = ol(n.href)),
+                  (n = ja(l).hoistableStyles),
+                  (a = n.get(e)),
+                  a ||
+                    ((a = {
+                      type: 'style',
+                      instance: null,
+                      count: 0,
+                      state: null,
+                    }),
+                    n.set(e, a)),
+                  a)
+                : { type: 'void', instance: null, count: 0, state: null }
+            case 'link':
+              if (
+                n.rel === 'stylesheet' &&
+                typeof n.href == 'string' &&
+                typeof n.precedence == 'string'
+              ) {
+                t = ol(n.href)
+                var s = ja(l).hoistableStyles,
+                  h = s.get(t)
+                if (
+                  (h ||
+                    ((l = l.ownerDocument || l),
+                    (h = {
+                      type: 'stylesheet',
+                      instance: null,
+                      count: 0,
+                      state: { loading: 0, preload: null },
+                    }),
+                    s.set(t, h),
+                    (s = l.querySelector(si(t))) &&
+                      !s._p &&
+                      ((h.instance = s), (h.state.loading = 5)),
+                    Be.has(t) ||
+                      ((n = {
+                        rel: 'preload',
+                        as: 'style',
+                        href: n.href,
+                        crossOrigin: n.crossOrigin,
+                        integrity: n.integrity,
+                        media: n.media,
+                        hrefLang: n.hrefLang,
+                        referrerPolicy: n.referrerPolicy,
+                      }),
+                      Be.set(t, n),
+                      s || Pm(l, t, n, h.state))),
+                  e && a === null)
+                )
+                  throw Error(f(528, ''))
+                return h
+              }
+              if (e && a !== null) throw Error(f(529, ''))
+              return null
+            case 'script':
+              return (
+                (e = n.async),
+                (n = n.src),
+                typeof n == 'string' &&
+                e &&
+                typeof e != 'function' &&
+                typeof e != 'symbol'
+                  ? ((e = dl(n)),
+                    (n = ja(l).hoistableScripts),
+                    (a = n.get(e)),
+                    a ||
+                      ((a = {
+                        type: 'script',
+                        instance: null,
+                        count: 0,
+                        state: null,
+                      }),
+                      n.set(e, a)),
+                    a)
+                  : { type: 'void', instance: null, count: 0, state: null }
+              )
+            default:
+              throw Error(f(444, t))
+          }
+        }
+        function ol(t) {
+          return 'href="' + Oe(t) + '"'
+        }
+        function si(t) {
+          return 'link[rel="stylesheet"][' + t + ']'
+        }
+        function Jd(t) {
+          return E({}, t, { 'data-precedence': t.precedence, precedence: null })
+        }
+        function Pm(t, e, n, a) {
+          t.querySelector('link[rel="preload"][as="style"][' + e + ']')
+            ? (a.loading = 1)
+            : ((e = t.createElement('link')),
+              (a.preload = e),
+              e.addEventListener('load', function () {
+                return (a.loading |= 1)
+              }),
+              e.addEventListener('error', function () {
+                return (a.loading |= 2)
+              }),
+              te(e, 'link', n),
+              kt(e),
+              t.head.appendChild(e))
+        }
+        function dl(t) {
+          return '[src="' + Oe(t) + '"]'
+        }
+        function fi(t) {
+          return 'script[async]' + t
+        }
+        function Pd(t, e, n) {
+          if ((e.count++, e.instance === null))
+            switch (e.type) {
+              case 'style':
+                var a = t.querySelector(
+                  'style[data-href~="' + Oe(n.href) + '"]',
+                )
+                if (a) return ((e.instance = a), kt(a), a)
+                var l = E({}, n, {
+                  'data-href': n.href,
+                  'data-precedence': n.precedence,
+                  href: null,
+                  precedence: null,
+                })
+                return (
+                  (a = (t.ownerDocument || t).createElement('style')),
+                  kt(a),
+                  te(a, 'style', l),
+                  Uu(a, n.precedence, t),
+                  (e.instance = a)
+                )
+              case 'stylesheet':
+                l = ol(n.href)
+                var s = t.querySelector(si(l))
+                if (s)
+                  return ((e.state.loading |= 4), (e.instance = s), kt(s), s)
+                ;((a = Jd(n)),
+                  (l = Be.get(l)) && df(a, l),
+                  (s = (t.ownerDocument || t).createElement('link')),
+                  kt(s))
+                var h = s
+                return (
+                  (h._p = new Promise(function (g, S) {
+                    ;((h.onload = g), (h.onerror = S))
+                  })),
+                  te(s, 'link', a),
+                  (e.state.loading |= 4),
+                  Uu(s, n.precedence, t),
+                  (e.instance = s)
+                )
+              case 'script':
+                return (
+                  (s = dl(n.src)),
+                  (l = t.querySelector(fi(s)))
+                    ? ((e.instance = l), kt(l), l)
+                    : ((a = n),
+                      (l = Be.get(s)) && ((a = E({}, n)), hf(a, l)),
+                      (t = t.ownerDocument || t),
+                      (l = t.createElement('script')),
+                      kt(l),
+                      te(l, 'link', a),
+                      t.head.appendChild(l),
+                      (e.instance = l))
+                )
+              case 'void':
+                return null
+              default:
+                throw Error(f(443, e.type))
+            }
+          else
+            e.type === 'stylesheet' &&
+              (e.state.loading & 4) === 0 &&
+              ((a = e.instance), (e.state.loading |= 4), Uu(a, n.precedence, t))
+          return e.instance
+        }
+        function Uu(t, e, n) {
+          for (
+            var a = n.querySelectorAll(
+                'link[rel="stylesheet"][data-precedence],style[data-precedence]',
+              ),
+              l = a.length ? a[a.length - 1] : null,
+              s = l,
+              h = 0;
+            h < a.length;
+            h++
+          ) {
+            var g = a[h]
+            if (g.dataset.precedence === e) s = g
+            else if (s !== l) break
+          }
+          s
+            ? s.parentNode.insertBefore(t, s.nextSibling)
+            : ((e = n.nodeType === 9 ? n.head : n),
+              e.insertBefore(t, e.firstChild))
+        }
+        function df(t, e) {
+          ;(t.crossOrigin == null && (t.crossOrigin = e.crossOrigin),
+            t.referrerPolicy == null && (t.referrerPolicy = e.referrerPolicy),
+            t.title == null && (t.title = e.title))
+        }
+        function hf(t, e) {
+          ;(t.crossOrigin == null && (t.crossOrigin = e.crossOrigin),
+            t.referrerPolicy == null && (t.referrerPolicy = e.referrerPolicy),
+            t.integrity == null && (t.integrity = e.integrity))
+        }
+        var Qu = null
+        function _d(t, e, n) {
+          if (Qu === null) {
+            var a = new Map(),
+              l = (Qu = new Map())
+            l.set(n, a)
+          } else ((l = Qu), (a = l.get(n)), a || ((a = new Map()), l.set(n, a)))
+          if (a.has(t)) return a
+          for (
+            a.set(t, null), n = n.getElementsByTagName(t), l = 0;
+            l < n.length;
+            l++
+          ) {
+            var s = n[l]
+            if (
+              !(
+                s[xl] ||
+                s[ne] ||
+                (t === 'link' && s.getAttribute('rel') === 'stylesheet')
+              ) &&
+              s.namespaceURI !== 'http://www.w3.org/2000/svg'
+            ) {
+              var h = s.getAttribute(e) || ''
+              h = t + h
+              var g = a.get(h)
+              g ? g.push(s) : a.set(h, [s])
+            }
+          }
+          return a
+        }
+        function $d(t, e, n) {
+          ;((t = t.ownerDocument || t),
+            t.head.insertBefore(
+              n,
+              e === 'title' ? t.querySelector('head > title') : null,
+            ))
+        }
+        function _m(t, e, n) {
+          if (n === 1 || e.itemProp != null) return !1
+          switch (t) {
+            case 'meta':
+            case 'title':
+              return !0
+            case 'style':
+              if (
+                typeof e.precedence != 'string' ||
+                typeof e.href != 'string' ||
+                e.href === ''
+              )
+                break
+              return !0
+            case 'link':
+              if (
+                typeof e.rel != 'string' ||
+                typeof e.href != 'string' ||
+                e.href === '' ||
+                e.onLoad ||
+                e.onError
+              )
+                break
+              switch (e.rel) {
+                case 'stylesheet':
+                  return (
+                    (t = e.disabled),
+                    typeof e.precedence == 'string' && t == null
+                  )
+                default:
+                  return !0
+              }
+            case 'script':
+              if (
+                e.async &&
+                typeof e.async != 'function' &&
+                typeof e.async != 'symbol' &&
+                !e.onLoad &&
+                !e.onError &&
+                e.src &&
+                typeof e.src == 'string'
+              )
+                return !0
+          }
+          return !1
+        }
+        function t1(t) {
+          return !(t.type === 'stylesheet' && (t.state.loading & 3) === 0)
+        }
+        var ri = null
+        function $m() {}
+        function tA(t, e, n) {
+          if (ri === null) throw Error(f(475))
+          var a = ri
+          if (
+            e.type === 'stylesheet' &&
+            (typeof n.media != 'string' ||
+              matchMedia(n.media).matches !== !1) &&
+            (e.state.loading & 4) === 0
+          ) {
+            if (e.instance === null) {
+              var l = ol(n.href),
+                s = t.querySelector(si(l))
+              if (s) {
+                ;((t = s._p),
+                  t !== null &&
+                    typeof t == 'object' &&
+                    typeof t.then == 'function' &&
+                    (a.count++, (a = Yu.bind(a)), t.then(a, a)),
+                  (e.state.loading |= 4),
+                  (e.instance = s),
+                  kt(s))
+                return
+              }
+              ;((s = t.ownerDocument || t),
+                (n = Jd(n)),
+                (l = Be.get(l)) && df(n, l),
+                (s = s.createElement('link')),
+                kt(s))
+              var h = s
+              ;((h._p = new Promise(function (g, S) {
+                ;((h.onload = g), (h.onerror = S))
+              })),
+                te(s, 'link', n),
+                (e.instance = s))
+            }
+            ;(a.stylesheets === null && (a.stylesheets = new Map()),
+              a.stylesheets.set(e, t),
+              (t = e.state.preload) &&
+                (e.state.loading & 3) === 0 &&
+                (a.count++,
+                (e = Yu.bind(a)),
+                t.addEventListener('load', e),
+                t.addEventListener('error', e)))
+          }
+        }
+        function eA() {
+          if (ri === null) throw Error(f(475))
+          var t = ri
+          return (
+            t.stylesheets && t.count === 0 && gf(t, t.stylesheets),
+            0 < t.count
+              ? function (e) {
+                  var n = setTimeout(function () {
+                    if ((t.stylesheets && gf(t, t.stylesheets), t.unsuspend)) {
+                      var a = t.unsuspend
+                      ;((t.unsuspend = null), a())
+                    }
+                  }, 6e4)
+                  return (
+                    (t.unsuspend = e),
+                    function () {
+                      ;((t.unsuspend = null), clearTimeout(n))
+                    }
+                  )
+                }
+              : null
+          )
+        }
+        function Yu() {
+          if ((this.count--, this.count === 0)) {
+            if (this.stylesheets) gf(this, this.stylesheets)
+            else if (this.unsuspend) {
+              var t = this.unsuspend
+              ;((this.unsuspend = null), t())
+            }
+          }
+        }
+        var Lu = null
+        function gf(t, e) {
+          ;((t.stylesheets = null),
+            t.unsuspend !== null &&
+              (t.count++,
+              (Lu = new Map()),
+              e.forEach(nA, t),
+              (Lu = null),
+              Yu.call(t)))
+        }
+        function nA(t, e) {
+          if (!(e.state.loading & 4)) {
+            var n = Lu.get(t)
+            if (n) var a = n.get(null)
+            else {
+              ;((n = new Map()), Lu.set(t, n))
+              for (
+                var l = t.querySelectorAll(
+                    'link[data-precedence],style[data-precedence]',
+                  ),
+                  s = 0;
+                s < l.length;
+                s++
+              ) {
+                var h = l[s]
+                ;(h.nodeName === 'LINK' ||
+                  h.getAttribute('media') !== 'not all') &&
+                  (n.set(h.dataset.precedence, h), (a = h))
+              }
+              a && n.set(null, a)
+            }
+            ;((l = e.instance),
+              (h = l.getAttribute('data-precedence')),
+              (s = n.get(h) || a),
+              s === a && n.set(null, l),
+              n.set(h, l),
+              this.count++,
+              (a = Yu.bind(this)),
+              l.addEventListener('load', a),
+              l.addEventListener('error', a),
+              s
+                ? s.parentNode.insertBefore(l, s.nextSibling)
+                : ((t = t.nodeType === 9 ? t.head : t),
+                  t.insertBefore(l, t.firstChild)),
+              (e.state.loading |= 4))
+          }
+        }
+        var oi = {
+          $$typeof: U,
+          Provider: null,
+          Consumer: null,
+          _currentValue: $,
+          _currentValue2: $,
+          _threadCount: 0,
+        }
+        function aA(t, e, n, a, l, s, h, g) {
+          ;((this.tag = 1),
+            (this.containerInfo = t),
+            (this.pingCache = this.current = this.pendingChildren = null),
+            (this.timeoutHandle = -1),
+            (this.callbackNode =
+              this.next =
+              this.pendingContext =
+              this.context =
+              this.cancelPendingCommit =
+                null),
+            (this.callbackPriority = 0),
+            (this.expirationTimes = fc(-1)),
+            (this.entangledLanes =
+              this.shellSuspendCounter =
+              this.errorRecoveryDisabledLanes =
+              this.expiredLanes =
+              this.warmLanes =
+              this.pingedLanes =
+              this.suspendedLanes =
+              this.pendingLanes =
+                0),
+            (this.entanglements = fc(0)),
+            (this.hiddenUpdates = fc(null)),
+            (this.identifierPrefix = a),
+            (this.onUncaughtError = l),
+            (this.onCaughtError = s),
+            (this.onRecoverableError = h),
+            (this.pooledCache = null),
+            (this.pooledCacheLanes = 0),
+            (this.formState = g),
+            (this.incompleteTransitions = new Map()))
+        }
+        function e1(t, e, n, a, l, s, h, g, S, B, X, k) {
+          return (
+            (t = new aA(t, e, n, h, g, S, B, k)),
+            (e = 1),
+            s === !0 && (e |= 24),
+            (s = Ee(3, null, null, e)),
+            (t.current = s),
+            (s.stateNode = t),
+            (e = Wc()),
+            e.refCount++,
+            (t.pooledCache = e),
+            e.refCount++,
+            (s.memoizedState = { element: a, isDehydrated: n, cache: e }),
+            _c(s),
+            t
+          )
+        }
+        function n1(t) {
+          return t ? ((t = Ia), t) : Ia
+        }
+        function a1(t, e, n, a, l, s) {
+          ;((l = n1(l)),
+            a.context === null ? (a.context = l) : (a.pendingContext = l),
+            (a = Rn(e)),
+            (a.payload = { element: n }),
+            (s = s === void 0 ? null : s),
+            s !== null && (a.callback = s),
+            (n = On(t, a, e)),
+            n !== null && (Te(n, t, e), Xl(n, t, e)))
+        }
+        function l1(t, e) {
+          if (((t = t.memoizedState), t !== null && t.dehydrated !== null)) {
+            var n = t.retryLane
+            t.retryLane = n !== 0 && n < e ? n : e
+          }
+        }
+        function mf(t, e) {
+          ;(l1(t, e), (t = t.alternate) && l1(t, e))
+        }
+        function i1(t) {
+          if (t.tag === 13) {
+            var e = Va(t, 67108864)
+            ;(e !== null && Te(e, t, 67108864), mf(t, 67108864))
+          }
+        }
+        var zu = !0
+        function lA(t, e, n, a) {
+          var l = M.T
+          M.T = null
+          var s = _.p
+          try {
+            ;((_.p = 2), Af(t, e, n, a))
+          } finally {
+            ;((_.p = s), (M.T = l))
+          }
+        }
+        function iA(t, e, n, a) {
+          var l = M.T
+          M.T = null
+          var s = _.p
+          try {
+            ;((_.p = 8), Af(t, e, n, a))
+          } finally {
+            ;((_.p = s), (M.T = l))
+          }
+        }
+        function Af(t, e, n, a) {
+          if (zu) {
+            var l = vf(a)
+            if (l === null) (nf(t, e, a, Gu, n), c1(t, a))
+            else if (cA(l, t, e, n, a)) a.stopPropagation()
+            else if ((c1(t, a), e & 4 && -1 < uA.indexOf(t))) {
+              for (; l !== null; ) {
+                var s = Ma(l)
+                if (s !== null)
+                  switch (s.tag) {
+                    case 3:
+                      if (
+                        ((s = s.stateNode),
+                        s.current.memoizedState.isDehydrated)
+                      ) {
+                        var h = aa(s.pendingLanes)
+                        if (h !== 0) {
+                          var g = s
+                          for (
+                            g.pendingLanes |= 2, g.entangledLanes |= 2;
+                            h;
+                          ) {
+                            var S = 1 << (31 - ve(h))
+                            ;((g.entanglements[1] |= S), (h &= ~S))
+                          }
+                          ;(ke(s), (St & 6) === 0 && ((Su = ce() + 500), li(0)))
+                        }
+                      }
+                      break
+                    case 13:
+                      ;((g = Va(s, 2)),
+                        g !== null && Te(g, s, 2),
+                        wu(),
+                        mf(s, 2))
+                  }
+                if (((s = vf(a)), s === null && nf(t, e, a, Gu, n), s === l))
+                  break
+                l = s
+              }
+              l !== null && a.stopPropagation()
+            } else nf(t, e, a, null, n)
+          }
+        }
+        function vf(t) {
+          return ((t = pc(t)), yf(t))
+        }
+        var Gu = null
+        function yf(t) {
+          if (((Gu = null), (t = Ca(t)), t !== null)) {
+            var e = o(t)
+            if (e === null) t = null
+            else {
+              var n = e.tag
+              if (n === 13) {
+                if (((t = d(e)), t !== null)) return t
+                t = null
+              } else if (n === 3) {
+                if (e.stateNode.current.memoizedState.isDehydrated)
+                  return e.tag === 3 ? e.stateNode.containerInfo : null
+                t = null
+              } else e !== t && (t = null)
+            }
+          }
+          return ((Gu = t), null)
+        }
+        function u1(t) {
+          switch (t) {
+            case 'beforetoggle':
+            case 'cancel':
+            case 'click':
+            case 'close':
+            case 'contextmenu':
+            case 'copy':
+            case 'cut':
+            case 'auxclick':
+            case 'dblclick':
+            case 'dragend':
+            case 'dragstart':
+            case 'drop':
+            case 'focusin':
+            case 'focusout':
+            case 'input':
+            case 'invalid':
+            case 'keydown':
+            case 'keypress':
+            case 'keyup':
+            case 'mousedown':
+            case 'mouseup':
+            case 'paste':
+            case 'pause':
+            case 'play':
+            case 'pointercancel':
+            case 'pointerdown':
+            case 'pointerup':
+            case 'ratechange':
+            case 'reset':
+            case 'resize':
+            case 'seeked':
+            case 'submit':
+            case 'toggle':
+            case 'touchcancel':
+            case 'touchend':
+            case 'touchstart':
+            case 'volumechange':
+            case 'change':
+            case 'selectionchange':
+            case 'textInput':
+            case 'compositionstart':
+            case 'compositionend':
+            case 'compositionupdate':
+            case 'beforeblur':
+            case 'afterblur':
+            case 'beforeinput':
+            case 'blur':
+            case 'fullscreenchange':
+            case 'focus':
+            case 'hashchange':
+            case 'popstate':
+            case 'select':
+            case 'selectstart':
+              return 2
+            case 'drag':
+            case 'dragenter':
+            case 'dragexit':
+            case 'dragleave':
+            case 'dragover':
+            case 'mousemove':
+            case 'mouseout':
+            case 'mouseover':
+            case 'pointermove':
+            case 'pointerout':
+            case 'pointerover':
+            case 'scroll':
+            case 'touchmove':
+            case 'wheel':
+            case 'mouseenter':
+            case 'mouseleave':
+            case 'pointerenter':
+            case 'pointerleave':
+              return 8
+            case 'message':
+              switch (sc()) {
+                case Er:
+                  return 2
+                case br:
+                  return 8
+                case Hi:
+                case kh:
+                  return 32
+                case pr:
+                  return 268435456
+                default:
+                  return 32
+              }
+            default:
+              return 32
+          }
+        }
+        var Ef = !1,
+          Gn = null,
+          Xn = null,
+          Vn = null,
+          di = new Map(),
+          hi = new Map(),
+          In = [],
+          uA =
+            'mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset'.split(
+              ' ',
+            )
+        function c1(t, e) {
+          switch (t) {
+            case 'focusin':
+            case 'focusout':
+              Gn = null
+              break
+            case 'dragenter':
+            case 'dragleave':
+              Xn = null
+              break
+            case 'mouseover':
+            case 'mouseout':
+              Vn = null
+              break
+            case 'pointerover':
+            case 'pointerout':
+              di.delete(e.pointerId)
+              break
+            case 'gotpointercapture':
+            case 'lostpointercapture':
+              hi.delete(e.pointerId)
+          }
+        }
+        function gi(t, e, n, a, l, s) {
+          return t === null || t.nativeEvent !== s
+            ? ((t = {
+                blockedOn: e,
+                domEventName: n,
+                eventSystemFlags: a,
+                nativeEvent: s,
+                targetContainers: [l],
+              }),
+              e !== null && ((e = Ma(e)), e !== null && i1(e)),
+              t)
+            : ((t.eventSystemFlags |= a),
+              (e = t.targetContainers),
+              l !== null && e.indexOf(l) === -1 && e.push(l),
+              t)
+        }
+        function cA(t, e, n, a, l) {
+          switch (e) {
+            case 'focusin':
+              return ((Gn = gi(Gn, t, e, n, a, l)), !0)
+            case 'dragenter':
+              return ((Xn = gi(Xn, t, e, n, a, l)), !0)
+            case 'mouseover':
+              return ((Vn = gi(Vn, t, e, n, a, l)), !0)
+            case 'pointerover':
+              var s = l.pointerId
+              return (di.set(s, gi(di.get(s) || null, t, e, n, a, l)), !0)
+            case 'gotpointercapture':
+              return (
+                (s = l.pointerId),
+                hi.set(s, gi(hi.get(s) || null, t, e, n, a, l)),
+                !0
+              )
+          }
+          return !1
+        }
+        function s1(t) {
+          var e = Ca(t.target)
+          if (e !== null) {
+            var n = o(e)
+            if (n !== null) {
+              if (((e = n.tag), e === 13)) {
+                if (((e = d(n)), e !== null)) {
+                  ;((t.blockedOn = e),
+                    tg(t.priority, function () {
+                      if (n.tag === 13) {
+                        var a = Se()
+                        a = rc(a)
+                        var l = Va(n, a)
+                        ;(l !== null && Te(l, n, a), mf(n, a))
+                      }
+                    }))
+                  return
+                }
+              } else if (
+                e === 3 &&
+                n.stateNode.current.memoizedState.isDehydrated
+              ) {
+                t.blockedOn = n.tag === 3 ? n.stateNode.containerInfo : null
+                return
+              }
+            }
+          }
+          t.blockedOn = null
+        }
+        function Xu(t) {
+          if (t.blockedOn !== null) return !1
+          for (var e = t.targetContainers; 0 < e.length; ) {
+            var n = vf(t.nativeEvent)
+            if (n === null) {
+              n = t.nativeEvent
+              var a = new n.constructor(n.type, n)
+              ;((bc = a), n.target.dispatchEvent(a), (bc = null))
+            } else
+              return ((e = Ma(n)), e !== null && i1(e), (t.blockedOn = n), !1)
+            e.shift()
+          }
+          return !0
+        }
+        function f1(t, e, n) {
+          Xu(t) && n.delete(e)
+        }
+        function sA() {
+          ;((Ef = !1),
+            Gn !== null && Xu(Gn) && (Gn = null),
+            Xn !== null && Xu(Xn) && (Xn = null),
+            Vn !== null && Xu(Vn) && (Vn = null),
+            di.forEach(f1),
+            hi.forEach(f1))
+        }
+        function Vu(t, e) {
+          t.blockedOn === e &&
+            ((t.blockedOn = null),
+            Ef ||
+              ((Ef = !0),
+              u.unstable_scheduleCallback(u.unstable_NormalPriority, sA)))
+        }
+        var Iu = null
+        function r1(t) {
+          Iu !== t &&
+            ((Iu = t),
+            u.unstable_scheduleCallback(u.unstable_NormalPriority, function () {
+              Iu === t && (Iu = null)
+              for (var e = 0; e < t.length; e += 3) {
+                var n = t[e],
+                  a = t[e + 1],
+                  l = t[e + 2]
+                if (typeof a != 'function') {
+                  if (yf(a || n) === null) continue
+                  break
+                }
+                var s = Ma(n)
+                s !== null &&
+                  (t.splice(e, 3),
+                  (e -= 3),
+                  vs(
+                    s,
+                    { pending: !0, data: l, method: n.method, action: a },
+                    a,
+                    l,
+                  ))
+              }
+            }))
+        }
+        function mi(t) {
+          function e(S) {
+            return Vu(S, t)
+          }
+          ;(Gn !== null && Vu(Gn, t),
+            Xn !== null && Vu(Xn, t),
+            Vn !== null && Vu(Vn, t),
+            di.forEach(e),
+            hi.forEach(e))
+          for (var n = 0; n < In.length; n++) {
+            var a = In[n]
+            a.blockedOn === t && (a.blockedOn = null)
+          }
+          for (; 0 < In.length && ((n = In[0]), n.blockedOn === null); )
+            (s1(n), n.blockedOn === null && In.shift())
+          if (((n = (t.ownerDocument || t).$$reactFormReplay), n != null))
+            for (a = 0; a < n.length; a += 3) {
+              var l = n[a],
+                s = n[a + 1],
+                h = l[re] || null
+              if (typeof s == 'function') h || r1(n)
+              else if (h) {
+                var g = null
+                if (s && s.hasAttribute('formAction')) {
+                  if (((l = s), (h = s[re] || null))) g = h.formAction
+                  else if (yf(l) !== null) continue
+                } else g = h.action
+                ;(typeof g == 'function'
+                  ? (n[a + 1] = g)
+                  : (n.splice(a, 3), (a -= 3)),
+                  r1(n))
+              }
+            }
+        }
+        function bf(t) {
+          this._internalRoot = t
+        }
+        ;((Zu.prototype.render = bf.prototype.render =
+          function (t) {
+            var e = this._internalRoot
+            if (e === null) throw Error(f(409))
+            var n = e.current,
+              a = Se()
+            a1(n, a, t, e, null, null)
+          }),
+          (Zu.prototype.unmount = bf.prototype.unmount =
+            function () {
+              var t = this._internalRoot
+              if (t !== null) {
+                this._internalRoot = null
+                var e = t.containerInfo
+                ;(a1(t.current, 2, null, t, null, null), wu(), (e[Da] = null))
+              }
+            }))
+        function Zu(t) {
+          this._internalRoot = t
+        }
+        Zu.prototype.unstable_scheduleHydration = function (t) {
+          if (t) {
+            var e = Rr()
+            t = { blockedOn: null, target: t, priority: e }
+            for (
+              var n = 0;
+              n < In.length && e !== 0 && e < In[n].priority;
+              n++
+            );
+            ;(In.splice(n, 0, t), n === 0 && s1(t))
+          }
+        }
+        var o1 = i.version
+        if (o1 !== '19.1.1') throw Error(f(527, o1, '19.1.1'))
+        _.findDOMNode = function (t) {
+          var e = t._reactInternals
+          if (e === void 0)
+            throw typeof t.render == 'function'
+              ? Error(f(188))
+              : ((t = Object.keys(t).join(',')), Error(f(268, t)))
+          return (
+            (t = v(e)),
+            (t = t !== null ? A(t) : null),
+            (t = t === null ? null : t.stateNode),
+            t
+          )
+        }
+        var fA = {
+          bundleType: 0,
+          version: '19.1.1',
+          rendererPackageName: 'react-dom',
+          currentDispatcherRef: M,
+          reconcilerVersion: '19.1.1',
+        }
+        if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < 'u') {
+          var qu = __REACT_DEVTOOLS_GLOBAL_HOOK__
+          if (!qu.isDisabled && qu.supportsFiber)
+            try {
+              ;((El = qu.inject(fA)), (Ae = qu))
+            } catch {}
+        }
+        return (
+          (Ei.createRoot = function (t, e) {
+            if (!r(t)) throw Error(f(299))
+            var n = !1,
+              a = '',
+              l = O0,
+              s = D0,
+              h = C0,
+              g = null
+            return (
+              e != null &&
+                (e.unstable_strictMode === !0 && (n = !0),
+                e.identifierPrefix !== void 0 && (a = e.identifierPrefix),
+                e.onUncaughtError !== void 0 && (l = e.onUncaughtError),
+                e.onCaughtError !== void 0 && (s = e.onCaughtError),
+                e.onRecoverableError !== void 0 && (h = e.onRecoverableError),
+                e.unstable_transitionCallbacks !== void 0 &&
+                  (g = e.unstable_transitionCallbacks)),
+              (e = e1(t, 1, !1, null, null, n, a, l, s, h, g, null)),
+              (t[Da] = e.current),
+              ef(t),
+              new bf(e)
+            )
+          }),
+          (Ei.hydrateRoot = function (t, e, n) {
+            if (!r(t)) throw Error(f(299))
+            var a = !1,
+              l = '',
+              s = O0,
+              h = D0,
+              g = C0,
+              S = null,
+              B = null
+            return (
+              n != null &&
+                (n.unstable_strictMode === !0 && (a = !0),
+                n.identifierPrefix !== void 0 && (l = n.identifierPrefix),
+                n.onUncaughtError !== void 0 && (s = n.onUncaughtError),
+                n.onCaughtError !== void 0 && (h = n.onCaughtError),
+                n.onRecoverableError !== void 0 && (g = n.onRecoverableError),
+                n.unstable_transitionCallbacks !== void 0 &&
+                  (S = n.unstable_transitionCallbacks),
+                n.formState !== void 0 && (B = n.formState)),
+              (e = e1(t, 1, !0, e, n ?? null, a, l, s, h, g, S, B)),
+              (e.context = n1(null)),
+              (n = e.current),
+              (a = Se()),
+              (a = rc(a)),
+              (l = Rn(a)),
+              (l.callback = null),
+              On(n, l, a),
+              (n = a),
+              (e.current.lanes = n),
+              pl(e, n),
+              ke(e),
+              (t[Da] = e.current),
+              ef(t),
+              new Zu(e)
+            )
+          }),
+          (Ei.version = '19.1.1'),
+          Ei
+        )
+      }
+      var g2
+      function y5() {
+        if (g2) return Nf.exports
+        g2 = 1
+        function u() {
+          if (
+            !(
+              typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ > 'u' ||
+              typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE != 'function'
+            )
+          )
+            try {
+              __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(u)
+            } catch (i) {
+              console.error(i)
+            }
+        }
+        return (u(), (Nf.exports = v5()), Nf.exports)
+      }
+      var E5 = y5()
+      class lc {
+        constructor() {
+          dn(this, 'project', [])
+          dn(this, 'status', [])
+          dn(this, 'text', [])
+          dn(this, 'labels', [])
+          dn(this, 'annotations', [])
+        }
+        empty() {
+          return (
+            this.project.length +
+              this.status.length +
+              this.text.length +
+              this.labels.length +
+              this.annotations.length ===
+            0
+          )
+        }
+        static parse(i) {
+          const c = lc.tokenize(i),
+            f = new Set(),
+            r = new Set(),
+            o = [],
+            d = new Set(),
+            y = new Set()
+          for (let A of c) {
+            const E = A.startsWith('!')
+            if ((E && (A = A.slice(1)), A.startsWith('p:'))) {
+              f.add({ name: A.slice(2), not: E })
+              continue
+            }
+            if (A.startsWith('s:')) {
+              r.add({ name: A.slice(2), not: E })
+              continue
+            }
+            if (A.startsWith('@')) {
+              d.add({ name: A, not: E })
+              continue
+            }
+            if (A.startsWith('annot:')) {
+              y.add({ name: A.slice(6), not: E })
+              continue
+            }
+            o.push({ name: A.toLowerCase(), not: E })
+          }
+          const v = new lc()
+          return (
+            (v.text = o),
+            (v.project = [...f]),
+            (v.status = [...r]),
+            (v.labels = [...d]),
+            (v.annotations = [...y]),
+            v
+          )
+        }
+        static tokenize(i) {
+          const c = []
+          let f,
+            r = []
+          for (let o = 0; o < i.length; ++o) {
+            const d = i[o]
+            if (f && d === '\\' && i[o + 1] === f) {
+              ;(r.push(f), ++o)
+              continue
+            }
+            if (d === '"' || d === "'") {
+              f === d
+                ? (c.push(r.join('').toLowerCase()), (r = []), (f = void 0))
+                : f
+                  ? r.push(d)
+                  : (f = d)
+              continue
+            }
+            if (f) {
+              r.push(d)
+              continue
+            }
+            if (d === ' ') {
+              r.length && (c.push(r.join('').toLowerCase()), (r = []))
+              continue
+            }
+            r.push(d)
+          }
+          return (r.length && c.push(r.join('').toLowerCase()), c)
+        }
+        matches(i) {
+          const c = b5(i)
+          if (
+            this.project.length &&
+            !!!this.project.find((r) => {
+              const o = c.project.includes(r.name)
+              return r.not ? !o : o
+            })
+          )
+            return !1
+          if (this.status.length) {
+            if (
+              !!!this.status.find((r) => {
+                const o = c.status.includes(r.name)
+                return r.not ? !o : o
+              })
+            )
+              return !1
+          } else if (c.status === 'skipped') return !1
+          return !(
+            (this.text.length &&
+              !this.text.every((r) => {
+                if (c.text.includes(r.name)) return !r.not
+                const [o, d, y] = r.name.split(':')
+                return c.file.includes(o) &&
+                  c.line === d &&
+                  (y === void 0 || c.column === y)
+                  ? !r.not
+                  : !!r.not
+              })) ||
+            (this.labels.length &&
+              !this.labels.every((r) => {
+                const o = c.labels.includes(r.name)
+                return r.not ? !o : o
+              })) ||
+            (this.annotations.length &&
+              !this.annotations.every((r) => {
+                const o = c.annotations.some((d) => d.includes(r.name))
+                return r.not ? !o : o
+              }))
+          )
+        }
+      }
+      const m2 = Symbol('searchValues')
+      function b5(u) {
+        const i = u[m2]
+        if (i) return i
+        let c = 'passed'
+        ;(u.outcome === 'unexpected' && (c = 'failed'),
+          u.outcome === 'flaky' && (c = 'flaky'),
+          u.outcome === 'skipped' && (c = 'skipped'))
+        const f = {
+          text: (
+            c +
+            ' ' +
+            u.projectName +
+            ' ' +
+            u.tags.join(' ') +
+            ' ' +
+            u.location.file +
+            ' ' +
+            u.path.join(' ') +
+            ' ' +
+            u.title
+          ).toLowerCase(),
+          project: u.projectName.toLowerCase(),
+          status: c,
+          file: u.location.file,
+          line: String(u.location.line),
+          column: String(u.location.column),
+          labels: u.tags.map((r) => r.toLowerCase()),
+          annotations: u.annotations.map((r) => {
+            var o
+            return (
+              r.type.toLowerCase() +
+              '=' +
+              ((o = r.description) == null ? void 0 : o.toLocaleLowerCase())
+            )
+          }),
+        }
+        return ((u[m2] = f), f)
+      }
+      const p5 = /("[^"]*"|"[^"]*$|\S+)/g
+      function wa(u, i, c) {
+        const f = new URLSearchParams(u),
+          o = [...(u.get('q') ?? '').matchAll(p5)].map((v) => {
+            const A = v[0]
+            return A.startsWith('"') && A.endsWith('"') && A.length > 1
+              ? A.slice(1, A.length - 1)
+              : A
+          })
+        if (c)
+          return (
+            f.set(
+              'q',
+              A2(o.includes(i) ? o.filter((v) => v !== i) : [...o, i]),
+            ),
+            '#?' + f
+          )
+        let d
+        ;(i.startsWith('s:') && (d = 's:'),
+          i.startsWith('p:') && (d = 'p:'),
+          i.startsWith('@') && (d = '@'))
+        const y = o.filter((v) => !v.startsWith(d))
+        return (y.push(i), f.set('q', A2(y)), '#?' + f)
+      }
+      function A2(u) {
+        return u
+          .map((i) => (/\s/.test(i) ? `"${i}"` : i))
+          .join(' ')
+          .trim()
+      }
+      const x5 = () =>
+          m.jsx('span', {
+            className: 'octicon',
+            style: { width: 16, height: 16 },
+          }),
+        S5 = () =>
+          m.jsx('svg', {
+            'aria-hidden': 'true',
+            height: '16',
+            viewBox: '0 0 16 16',
+            version: '1.1',
+            width: '16',
+            'data-view-component': 'true',
+            className: 'octicon subnav-search-icon',
+            children: m.jsx('path', {
+              fillRule: 'evenodd',
+              d: 'M11.5 7a4.499 4.499 0 11-8.998 0A4.499 4.499 0 0111.5 7zm-.82 4.74a6 6 0 111.06-1.06l3.04 3.04a.75.75 0 11-1.06 1.06l-3.04-3.04z',
+            }),
+          }),
+        Mi = () =>
+          m.jsx('svg', {
+            'aria-hidden': 'true',
+            height: '16',
+            viewBox: '0 0 16 16',
+            version: '1.1',
+            width: '16',
+            className: 'octicon color-fg-muted',
+            children: m.jsx('path', {
+              fillRule: 'evenodd',
+              d: 'M12.78 6.22a.75.75 0 010 1.06l-4.25 4.25a.75.75 0 01-1.06 0L3.22 7.28a.75.75 0 011.06-1.06L8 9.94l3.72-3.72a.75.75 0 011.06 0z',
+            }),
+          }),
+        vl = () =>
+          m.jsx('svg', {
+            'aria-hidden': 'true',
+            height: '16',
+            viewBox: '0 0 16 16',
+            version: '1.1',
+            width: '16',
+            'data-view-component': 'true',
+            className: 'octicon color-fg-muted',
+            children: m.jsx('path', {
+              fillRule: 'evenodd',
+              d: 'M6.22 3.22a.75.75 0 011.06 0l4.25 4.25a.75.75 0 010 1.06l-4.25 4.25a.75.75 0 01-1.06-1.06L9.94 8 6.22 4.28a.75.75 0 010-1.06z',
+            }),
+          }),
+        Dh = () =>
+          m.jsx('svg', {
+            'aria-hidden': 'true',
+            height: '16',
+            viewBox: '0 0 16 16',
+            version: '1.1',
+            width: '16',
+            'data-view-component': 'true',
+            className: 'octicon color-text-warning',
+            children: m.jsx('path', {
+              fillRule: 'evenodd',
+              d: 'M8.22 1.754a.25.25 0 00-.44 0L1.698 13.132a.25.25 0 00.22.368h12.164a.25.25 0 00.22-.368L8.22 1.754zm-1.763-.707c.659-1.234 2.427-1.234 3.086 0l6.082 11.378A1.75 1.75 0 0114.082 15H1.918a1.75 1.75 0 01-1.543-2.575L6.457 1.047zM9 11a1 1 0 11-2 0 1 1 0 012 0zm-.25-5.25a.75.75 0 00-1.5 0v2.5a.75.75 0 001.5 0v-2.5z',
+            }),
+          }),
+        Ch = () =>
+          m.jsx('svg', {
+            'aria-hidden': 'true',
+            height: '16',
+            viewBox: '0 0 16 16',
+            version: '1.1',
+            width: '16',
+            'data-view-component': 'true',
+            className: 'octicon color-fg-muted',
+            children: m.jsx('path', {
+              fillRule: 'evenodd',
+              d: 'M3.5 1.75a.25.25 0 01.25-.25h3a.75.75 0 000 1.5h.5a.75.75 0 000-1.5h2.086a.25.25 0 01.177.073l2.914 2.914a.25.25 0 01.073.177v8.586a.25.25 0 01-.25.25h-.5a.75.75 0 000 1.5h.5A1.75 1.75 0 0014 13.25V4.664c0-.464-.184-.909-.513-1.237L10.573.513A1.75 1.75 0 009.336 0H3.75A1.75 1.75 0 002 1.75v11.5c0 .649.353 1.214.874 1.515a.75.75 0 10.752-1.298.25.25 0 01-.126-.217V1.75zM8.75 3a.75.75 0 000 1.5h.5a.75.75 0 000-1.5h-.5zM6 5.25a.75.75 0 01.75-.75h.5a.75.75 0 010 1.5h-.5A.75.75 0 016 5.25zm2 1.5A.75.75 0 018.75 6h.5a.75.75 0 010 1.5h-.5A.75.75 0 018 6.75zm-1.25.75a.75.75 0 000 1.5h.5a.75.75 0 000-1.5h-.5zM8 9.75A.75.75 0 018.75 9h.5a.75.75 0 010 1.5h-.5A.75.75 0 018 9.75zm-.75.75a1.75 1.75 0 00-1.75 1.75v3c0 .414.336.75.75.75h2.5a.75.75 0 00.75-.75v-3a1.75 1.75 0 00-1.75-1.75h-.5zM7 12.25a.25.25 0 01.25-.25h.5a.25.25 0 01.25.25v2.25H7v-2.25z',
+            }),
+          }),
+        Mh = () =>
+          m.jsx('svg', {
+            className: 'octicon color-text-danger',
+            viewBox: '0 0 16 16',
+            version: '1.1',
+            width: '16',
+            height: '16',
+            'aria-hidden': 'true',
+            children: m.jsx('path', {
+              fillRule: 'evenodd',
+              d: 'M3.72 3.72a.75.75 0 011.06 0L8 6.94l3.22-3.22a.75.75 0 111.06 1.06L9.06 8l3.22 3.22a.75.75 0 11-1.06 1.06L8 9.06l-3.22 3.22a.75.75 0 01-1.06-1.06L6.94 8 3.72 4.78a.75.75 0 010-1.06z',
+            }),
+          }),
+        jh = () =>
+          m.jsx('svg', {
+            'aria-hidden': 'true',
+            height: '16',
+            viewBox: '0 0 16 16',
+            version: '1.1',
+            width: '16',
+            'data-view-component': 'true',
+            className: 'octicon color-icon-success',
+            children: m.jsx('path', {
+              fillRule: 'evenodd',
+              d: 'M13.78 4.22a.75.75 0 010 1.06l-7.25 7.25a.75.75 0 01-1.06 0L2.22 9.28a.75.75 0 011.06-1.06L6 10.94l6.72-6.72a.75.75 0 011.06 0z',
+            }),
+          }),
+        Hh = () =>
+          m.jsx('svg', {
+            'aria-hidden': 'true',
+            height: '16',
+            viewBox: '0 0 16 16',
+            version: '1.1',
+            width: '16',
+            'data-view-component': 'true',
+            className: 'octicon octicon-clock color-text-danger',
+            children: m.jsx('path', {
+              fillRule: 'evenodd',
+              d: 'M5.75.75A.75.75 0 016.5 0h3a.75.75 0 010 1.5h-.75v1l-.001.041a6.718 6.718 0 013.464 1.435l.007-.006.75-.75a.75.75 0 111.06 1.06l-.75.75-.006.007a6.75 6.75 0 11-10.548 0L2.72 5.03l-.75-.75a.75.75 0 011.06-1.06l.75.75.007.006A6.718 6.718 0 017.25 2.541a.756.756 0 010-.041v-1H6.5a.75.75 0 01-.75-.75zM8 14.5A5.25 5.25 0 108 4a5.25 5.25 0 000 10.5zm.389-6.7l1.33-1.33a.75.75 0 111.061 1.06L9.45 8.861A1.502 1.502 0 018 10.75a1.5 1.5 0 11.389-2.95z',
+            }),
+          }),
+        T5 = () =>
+          m.jsx('svg', {
+            'aria-hidden': 'true',
+            viewBox: '0 0 16 16',
+            width: '16',
+            height: '16',
+            'data-view-component': 'true',
+            className: 'octicon color-fg-muted',
+            children: m.jsx('path', {
+              d: 'M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm9.78-2.22-5.5 5.5a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734l5.5-5.5a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042Z',
+            }),
+          }),
+        w5 = () =>
+          m.jsx('svg', {
+            className: 'octicon',
+            viewBox: '0 0 48 48',
+            version: '1.1',
+            width: '20',
+            height: '20',
+            'aria-hidden': 'true',
+            children: m.jsx('path', {
+              xmlns: 'http://www.w3.org/2000/svg',
+              d: 'M11.85 32H36.2l-7.35-9.95-6.55 8.7-4.6-6.45ZM7 40q-1.2 0-2.1-.9Q4 38.2 4 37V11q0-1.2.9-2.1Q5.8 8 7 8h34q1.2 0 2.1.9.9.9.9 2.1v26q0 1.2-.9 2.1-.9.9-2.1.9Zm0-29v26-26Zm34 26V11H7v26Z',
+            }),
+          }),
+        R5 = () =>
+          m.jsx('svg', {
+            className: 'octicon',
+            viewBox: '0 0 48 48',
+            version: '1.1',
+            width: '20',
+            height: '20',
+            'aria-hidden': 'true',
+            children: m.jsx('path', {
+              xmlns: 'http://www.w3.org/2000/svg',
+              d: 'm19.6 32.35 13-8.45-13-8.45ZM7 40q-1.2 0-2.1-.9Q4 38.2 4 37V11q0-1.2.9-2.1Q5.8 8 7 8h34q1.2 0 2.1.9.9.9.9 2.1v26q0 1.2-.9 2.1-.9.9-2.1.9Zm0-3h34V11H7v26Zm0 0V11v26Z',
+            }),
+          }),
+        O5 = () =>
+          m.jsx('svg', {
+            className: 'octicon',
+            viewBox: '0 0 48 48',
+            version: '1.1',
+            width: '20',
+            height: '20',
+            'aria-hidden': 'true',
+            children: m.jsx('path', {
+              xmlns: 'http://www.w3.org/2000/svg',
+              d: 'M7 37h9.35V11H7v26Zm12.35 0h9.3V11h-9.3v26Zm12.3 0H41V11h-9.35v26ZM7 40q-1.2 0-2.1-.9Q4 38.2 4 37V11q0-1.2.9-2.1Q5.8 8 7 8h34q1.2 0 2.1.9.9.9.9 2.1v26q0 1.2-.9 2.1-.9.9-2.1.9Z',
+            }),
+          }),
+        D5 = () =>
+          m.jsxs('svg', {
+            className: 'octicon',
+            viewBox: '0 0 16 16',
+            width: '16',
+            height: '16',
+            'aria-hidden': 'true',
+            children: [
+              m.jsx('path', {
+                d: 'M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z',
+              }),
+              m.jsx('path', {
+                d: 'M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z',
+              }),
+            ],
+          }),
+        C5 = () =>
+          m.jsx('svg', {
+            className: 'octicon octicon-settings',
+            viewBox: '0 0 16 16',
+            width: '16',
+            height: '16',
+            'aria-hidden': 'true',
+            children: m.jsx('path', {
+              d: 'M8 0a8.2 8.2 0 0 1 .701.031C9.444.095 9.99.645 10.16 1.29l.288 1.107c.018.066.079.158.212.224.231.114.454.243.668.386.123.082.233.09.299.071l1.103-.303c.644-.176 1.392.021 1.82.63.27.385.506.792.704 1.218.315.675.111 1.422-.364 1.891l-.814.806c-.049.048-.098.147-.088.294.016.257.016.515 0 .772-.01.147.038.246.088.294l.814.806c.475.469.679 1.216.364 1.891a7.977 7.977 0 0 1-.704 1.217c-.428.61-1.176.807-1.82.63l-1.102-.302c-.067-.019-.177-.011-.3.071a5.909 5.909 0 0 1-.668.386c-.133.066-.194.158-.211.224l-.29 1.106c-.168.646-.715 1.196-1.458 1.26a8.006 8.006 0 0 1-1.402 0c-.743-.064-1.289-.614-1.458-1.26l-.289-1.106c-.018-.066-.079-.158-.212-.224a5.738 5.738 0 0 1-.668-.386c-.123-.082-.233-.09-.299-.071l-1.103.303c-.644.176-1.392-.021-1.82-.63a8.12 8.12 0 0 1-.704-1.218c-.315-.675-.111-1.422.363-1.891l.815-.806c.05-.048.098-.147.088-.294a6.214 6.214 0 0 1 0-.772c.01-.147-.038-.246-.088-.294l-.815-.806C.635 6.045.431 5.298.746 4.623a7.92 7.92 0 0 1 .704-1.217c.428-.61 1.176-.807 1.82-.63l1.102.302c.067.019.177.011.3-.071.214-.143.437-.272.668-.386.133-.066.194-.158.211-.224l.29-1.106C6.009.645 6.556.095 7.299.03 7.53.01 7.764 0 8 0Zm-.571 1.525c-.036.003-.108.036-.137.146l-.289 1.105c-.147.561-.549.967-.998 1.189-.173.086-.34.183-.5.29-.417.278-.97.423-1.529.27l-1.103-.303c-.109-.03-.175.016-.195.045-.22.312-.412.644-.573.99-.014.031-.021.11.059.19l.815.806c.411.406.562.957.53 1.456a4.709 4.709 0 0 0 0 .582c.032.499-.119 1.05-.53 1.456l-.815.806c-.081.08-.073.159-.059.19.162.346.353.677.573.989.02.03.085.076.195.046l1.102-.303c.56-.153 1.113-.008 1.53.27.161.107.328.204.501.29.447.222.85.629.997 1.189l.289 1.105c.029.109.101.143.137.146a6.6 6.6 0 0 0 1.142 0c.036-.003.108-.036.137-.146l.289-1.105c.147-.561.549-.967.998-1.189.173-.086.34-.183.5-.29.417-.278.97-.423 1.529-.27l1.103.303c.109.029.175-.016.195-.045.22-.313.411-.644.573-.99.014-.031.021-.11-.059-.19l-.815-.806c-.411-.406-.562-.957-.53-1.456a4.709 4.709 0 0 0 0-.582c-.032-.499.119-1.05.53-1.456l.815-.806c.081-.08.073-.159.059-.19a6.464 6.464 0 0 0-.573-.989c-.02-.03-.085-.076-.195-.046l-1.102.303c-.56.153-1.113.008-1.53-.27a4.44 4.44 0 0 0-.501-.29c-.447-.222-.85-.629-.997-1.189l-.289-1.105c-.029-.11-.101-.143-.137-.146a6.6 6.6 0 0 0-1.142 0ZM11 8a3 3 0 1 1-6 0 3 3 0 0 1 6 0ZM9.5 8a1.5 1.5 0 1 0-3.001.001A1.5 1.5 0 0 0 9.5 8Z',
+            }),
+          }),
+        Nh = ({ value: u }) => {
+          const [i, c] = ct.useState('copy'),
+            f = ct.useCallback(() => {
+              navigator.clipboard.writeText(u).then(
+                () => {
+                  ;(c('check'),
+                    setTimeout(() => {
+                      c('copy')
+                    }, 3e3))
+                },
+                () => {
+                  c('cross')
+                },
+              )
+            }, [u]),
+            r = i === 'check' ? jh() : i === 'cross' ? Mh() : D5()
+          return m.jsx('button', {
+            className: 'copy-icon',
+            title: 'Copy to clipboard',
+            'aria-label': 'Copy to clipboard',
+            onClick: f,
+            children: r,
+          })
+        },
+        hr = ({ children: u, value: i }) =>
+          m.jsxs('span', {
+            className: 'copy-value-container',
+            children: [
+              u,
+              m.jsx('span', {
+                className: 'copy-button-container',
+                children: m.jsx(Nh, { value: i }),
+              }),
+            ],
+          })
+      function M5(u, i, c, f) {
+        const [r, o] = ie.useState(c)
+        return (
+          ie.useEffect(() => {
+            let d = !1
+            return (
+              u().then((y) => {
+                d || o(y)
+              }),
+              () => {
+                d = !0
+              }
+            )
+          }, i),
+          r
+        )
+      }
+      function Bh() {
+        const u = ie.useRef(null),
+          [i] = Pf(u)
+        return [i, u]
+      }
+      function Pf(u) {
+        const [i, c] = ie.useState(new DOMRect(0, 0, 10, 10)),
+          f = ie.useCallback(() => {
+            const r = u == null ? void 0 : u.current
+            r && c(r.getBoundingClientRect())
+          }, [u])
+        return (
+          ie.useLayoutEffect(() => {
+            const r = u == null ? void 0 : u.current
+            if (!r) return
+            f()
+            const o = new ResizeObserver(f)
+            return (
+              o.observe(r),
+              window.addEventListener('resize', f),
+              () => {
+                ;(o.disconnect(), window.removeEventListener('resize', f))
+              }
+            )
+          }, [f, u]),
+          [i, f]
+        )
+      }
+      function Uh(u, i) {
+        i = xa.getObject(u, i)
+        const [c, f] = ie.useState(i),
+          r = ie.useCallback(
+            (o) => {
+              xa.setObject(u, o)
+            },
+            [u, f],
+          )
+        return (
+          ie.useEffect(() => {
+            {
+              const o = () => f(xa.getObject(u, i))
+              return (
+                xa.onChangeEmitter.addEventListener(u, o),
+                () => xa.onChangeEmitter.removeEventListener(u, o)
+              )
+            }
+          }, [i, u]),
+          [c, r]
+        )
+      }
+      class j5 {
+        constructor() {
+          this.onChangeEmitter = new EventTarget()
+        }
+        getString(i, c) {
+          return localStorage[i] || c
+        }
+        setString(i, c) {
+          var f
+          ;((localStorage[i] = c),
+            this.onChangeEmitter.dispatchEvent(new Event(i)),
+            (f = window.saveSettings) == null || f.call(window))
+        }
+        getObject(i, c) {
+          if (!localStorage[i]) return c
+          try {
+            return JSON.parse(localStorage[i])
+          } catch {
+            return c
+          }
+        }
+        setObject(i, c) {
+          var f
+          ;((localStorage[i] = JSON.stringify(c)),
+            this.onChangeEmitter.dispatchEvent(new Event(i)),
+            (f = window.saveSettings) == null || f.call(window))
+        }
+      }
+      const xa = new j5()
+      function Ye(...u) {
+        return u.filter(Boolean).join(' ')
+      }
+      const v2 = '\\u0000-\\u0020\\u007f-\\u009f',
+        H5 = new RegExp(
+          '(?:[a-zA-Z][a-zA-Z0-9+.-]{2,}:\\/\\/|www\\.)[^\\s' +
+            v2 +
+            '"]{2,}[^\\s' +
+            v2 +
+            `"')}\\],:;.!?]`,
+          'ug',
+        )
+      function N5() {
+        const [u, i] = ie.useState(!1),
+          c = ie.useCallback(() => {
+            const f = []
+            return (
+              i(
+                (r) => (
+                  f.push(setTimeout(() => i(!1), 1e3)),
+                  r ? (f.push(setTimeout(() => i(!0), 50)), !1) : !0
+                ),
+              ),
+              () => f.forEach(clearTimeout)
+            )
+          }, [i])
+        return [u, c]
+      }
+      function Ri(u) {
+        const i = []
+        let c = 0,
+          f
+        for (; (f = H5.exec(u)) !== null; ) {
+          const o = u.substring(c, f.index)
+          o && i.push(o)
+          const d = f[0]
+          ;(i.push(B5(d)), (c = f.index + d.length))
+        }
+        const r = u.substring(c)
+        return (r && i.push(r), i)
+      }
+      function B5(u) {
+        let i = u
+        return (
+          i.startsWith('www.') && (i = 'https://' + i),
+          m.jsx('a', {
+            href: i,
+            target: '_blank',
+            rel: 'noopener noreferrer',
+            children: u,
+          })
+        )
+      }
+      const U5 = ({ summary: u, children: i, className: c, style: f }) => {
+        const [r, o] = ie.useState(!1),
+          d = (y) => {
+            o(y.currentTarget.open)
+          }
+        return m.jsxs('details', {
+          style: f,
+          className: c,
+          onToggle: d,
+          children: [
+            m.jsxs('summary', {
+              className: 'expandable-summary',
+              children: [r ? Mi() : vl(), u],
+            }),
+            i,
+          ],
+        })
+      }
+      function yl(u) {
+        if (!isFinite(u)) return '-'
+        if (u === 0) return '0ms'
+        if (u < 1e3) return u.toFixed(0) + 'ms'
+        const i = u / 1e3
+        if (i < 60) return i.toFixed(1) + 's'
+        const c = i / 60
+        if (c < 60) return c.toFixed(1) + 'm'
+        const f = c / 60
+        return f < 24 ? f.toFixed(1) + 'h' : (f / 24).toFixed(1) + 'd'
+      }
+      function Q5(u) {
+        let i = 0
+        for (let c = 0; c < u.length; c++) i = u.charCodeAt(c) + ((i << 8) - i)
+        return Math.abs(i % 6)
+      }
+      function Qe(u) {
+        if (!u) return u
+        try {
+          const i = new URL(u, window.location.href)
+          if (i.origin === window.location.origin) {
+            for (const [c, f] of new URLSearchParams(window.location.search))
+              i.searchParams.append(c, f)
+            return i.toString()
+          }
+          return u
+        } catch {
+          return u
+        }
+      }
+      const Qh = ({
+          label: u,
+          href: i,
+          onClick: c,
+          colorIndex: f,
+          trimAtSymbolPrefix: r,
+        }) => {
+          const o = m.jsx('span', {
+            className: Ye('label', 'label-color-' + (f !== void 0 ? f : Q5(u))),
+            onClick: c ? (d) => c(d, u) : void 0,
+            children: r && u.startsWith('@') ? u.slice(1) : u,
+          })
+          return i
+            ? m.jsx('a', {
+                className: 'label-anchor',
+                href: Qe(i),
+                children: o,
+              })
+            : o
+        },
+        Yh = ({
+          projectNames: u,
+          activeProjectName: i,
+          otherLabels: c,
+          style: f,
+        }) =>
+          ((u.length > 0 && !!i) || c.length > 0) &&
+          m.jsxs('span', {
+            className: 'label-row',
+            style: f ?? {},
+            children: [
+              m.jsx(L5, { projectNames: u, projectName: i }),
+              m.jsx(Y5, { labels: c }),
+            ],
+          }),
+        Y5 = ({ labels: u }) => {
+          const i = ue(),
+            c = ct.useCallback(
+              (f, r) => {
+                ;(f.preventDefault(),
+                  i.has('testId') && i.delete('speedboard'),
+                  i.delete('testId'),
+                  _n(wa(i, r, f.metaKey || f.ctrlKey)))
+              },
+              [i],
+            )
+          return m.jsx(m.Fragment, {
+            children: u.map((f) =>
+              m.jsx(Qh, { label: f, trimAtSymbolPrefix: !0, onClick: c }, f),
+            ),
+          })
+        }
+      function _n(u) {
+        window.history.pushState({}, '', u)
+        const i = new PopStateEvent('popstate')
+        window.dispatchEvent(i)
+      }
+      const Yf = ({ predicate: u, children: i }) => {
+          const c = ue()
+          return u(c) ? i : null
+        },
+        yn = ({ click: u, ctrlClick: i, children: c, ...f }) =>
+          m.jsx('a', {
+            ...f,
+            style: {
+              textDecoration: 'none',
+              color: 'var(--color-fg-default)',
+              cursor: 'pointer',
+            },
+            onClick: (r) => {
+              u &&
+                (r.preventDefault(),
+                _n(Qe(((r.metaKey || r.ctrlKey) && i) || u)))
+            },
+            children: c,
+          }),
+        gr = ({ className: u, ...i }) =>
+          m.jsx(yn, {
+            ...i,
+            className: Ye('link-badge', i.dim && 'link-badge-dim', u),
+          }),
+        L5 = ({ projectNames: u, projectName: i }) => {
+          const c = ue()
+          return (
+            c.has('testId') && c.delete('speedboard'),
+            c.delete('testId'),
+            m.jsx(yn, {
+              click: wa(c, `p:${i}`, !1),
+              ctrlClick: wa(c, `p:${i}`, !0),
+              children: m.jsx(Qh, { label: i, colorIndex: u.indexOf(i) % 6 }),
+            })
+          )
+        },
+        Ju = ({
+          attachment: u,
+          result: i,
+          href: c,
+          linkName: f,
+          openInNewTab: r,
+        }) => {
+          const [o, d] = N5()
+          mr('attachment-' + i.attachments.indexOf(u), d)
+          const y = m.jsxs('span', {
+            children: [
+              u.contentType === X5 ? Dh() : Ch(),
+              u.path &&
+                (r
+                  ? m.jsx('a', {
+                      href: Qe(c || u.path),
+                      target: '_blank',
+                      rel: 'noreferrer',
+                      children: f || u.name,
+                    })
+                  : m.jsx('a', {
+                      href: Qe(c || u.path),
+                      download: G5(u),
+                      children: f || u.name,
+                    })),
+              !u.path &&
+                (r
+                  ? m.jsx('a', {
+                      href: URL.createObjectURL(
+                        new Blob([u.body], { type: u.contentType }),
+                      ),
+                      target: '_blank',
+                      rel: 'noreferrer',
+                      onClick: (v) => v.stopPropagation(),
+                      children: u.name,
+                    })
+                  : m.jsx('span', { children: Ri(u.name) })),
+            ],
+          })
+          return u.body
+            ? m.jsx(U5, {
+                style: { lineHeight: '32px' },
+                className: Ye(o && 'flash'),
+                summary: y,
+                children: m.jsxs('div', {
+                  className: 'attachment-body',
+                  children: [m.jsx(Nh, { value: u.body }), Ri(u.body)],
+                }),
+              })
+            : m.jsxs('div', {
+                style: {
+                  lineHeight: '32px',
+                  whiteSpace: 'nowrap',
+                  paddingLeft: 4,
+                },
+                className: Ye(o && 'flash'),
+                children: [
+                  m.jsx('span', {
+                    style: { visibility: 'hidden' },
+                    children: vl(),
+                  }),
+                  y,
+                ],
+              })
+        },
+        Lh = ({ test: u, trailingSeparator: i, dim: c }) => {
+          const f = u.results
+            .map((r) => r.attachments.filter((o) => o.name === 'trace'))
+            .filter((r) => r.length > 0)[0]
+          if (f)
+            return m.jsxs(m.Fragment, {
+              children: [
+                m.jsxs(gr, {
+                  href: Qe(Gh(f)),
+                  title: 'View Trace',
+                  className: 'button trace-link',
+                  dim: c,
+                  children: [O5(), m.jsx('span', { children: 'View Trace' })],
+                }),
+                i &&
+                  m.jsx('div', {
+                    className: 'trace-link-separator',
+                    children: '|',
+                  }),
+              ],
+            })
+        },
+        zh = ct.createContext(
+          new URLSearchParams(window.location.hash.slice(1)),
+        )
+      function ue() {
+        return new URLSearchParams(ct.useContext(zh))
+      }
+      const z5 = ({ children: u }) => {
+        const [i, c] = ct.useState(
+          new URLSearchParams(window.location.hash.slice(1)),
+        )
+        return (
+          ct.useEffect(() => {
+            const f = () =>
+              c(new URLSearchParams(window.location.hash.slice(1)))
+            return (
+              window.addEventListener('popstate', f),
+              () => window.removeEventListener('popstate', f)
+            )
+          }, []),
+          m.jsx(zh.Provider, { value: i, children: u })
+        )
+      }
+      function G5(u) {
+        if (u.name.includes('.') || !u.path) return u.name
+        const i = u.path.indexOf('.')
+        return i === -1 ? u.name : u.name + u.path.slice(i, u.path.length)
+      }
+      function Gh(u) {
+        return `trace/index.html?${u.map((i, c) => `trace=${new URL(i.path, window.location.href)}`).join('&')}`
+      }
+      const X5 = 'x-playwright/missing'
+      function mr(u, i) {
+        const c = ue(),
+          f = V5(u)
+        ct.useEffect(() => {
+          if (f) return i()
+        }, [f, i, c])
+      }
+      function V5(u) {
+        const c = ue().get('anchor')
+        return c === null || typeof u > 'u'
+          ? !1
+          : typeof u == 'string'
+            ? u === c
+            : Array.isArray(u)
+              ? u.includes(c)
+              : u(c)
+      }
+      function bi({ id: u, children: i }) {
+        const c = ct.useRef(null),
+          f = ct.useCallback(() => {
+            var r
+            ;(r = c.current) == null ||
+              r.scrollIntoView({ block: 'start', inline: 'start' })
+          }, [])
+        return (mr(u, f), m.jsx('div', { ref: c, children: i }))
+      }
+      function En({ test: u, result: i, anchor: c }, f) {
+        const r = new URLSearchParams(f)
+        return (
+          u && r.set('testId', u.testId),
+          u && i && r.set('run', '' + u.results.indexOf(i)),
+          c && r.set('anchor', c),
+          '#?' + r
+        )
+      }
+      function cc(u) {
+        switch (u) {
+          case 'failed':
+          case 'unexpected':
+            return Mh()
+          case 'passed':
+          case 'expected':
+            return jh()
+          case 'timedOut':
+            return Hh()
+          case 'flaky':
+            return Dh()
+          case 'skipped':
+          case 'interrupted':
+            return T5()
+        }
+      }
+      const I5 = ({
+        className: u,
+        style: i,
+        open: c,
+        isModal: f,
+        minWidth: r,
+        verticalOffset: o,
+        requestClose: d,
+        anchor: y,
+        dataTestId: v,
+        children: A,
+      }) => {
+        const E = ct.useRef(null),
+          [w, R] = ct.useState(0),
+          [z] = Pf(E),
+          [N, x] = Pf(y),
+          p = Z5(z, N, o)
+        return (
+          ct.useEffect(() => {
+            const T = (U) => {
+                !E.current ||
+                  !(U.target instanceof Node) ||
+                  E.current.contains(U.target) ||
+                  d == null ||
+                  d()
+              },
+              D = (U) => {
+                U.key === 'Escape' && (d == null || d())
+              }
+            return c
+              ? (document.addEventListener('mousedown', T),
+                document.addEventListener('keydown', D),
+                () => {
+                  ;(document.removeEventListener('mousedown', T),
+                    document.removeEventListener('keydown', D))
+                })
+              : () => {}
+          }, [c, d]),
+          ct.useLayoutEffect(() => x(), [c, x]),
+          ct.useEffect(() => {
+            const T = () => R((D) => D + 1)
+            return (
+              window.addEventListener('resize', T),
+              () => {
+                window.removeEventListener('resize', T)
+              }
+            )
+          }, []),
+          ct.useLayoutEffect(() => {
+            E.current &&
+              (c
+                ? f
+                  ? E.current.showModal()
+                  : E.current.show()
+                : E.current.close())
+          }, [c, f]),
+          m.jsx('dialog', {
+            ref: E,
+            style: {
+              position: 'fixed',
+              margin: 0,
+              zIndex: 110,
+              top: p.top,
+              left: p.left,
+              minWidth: r || 0,
+              ...i,
+            },
+            className: u,
+            'data-testid': v,
+            children: A,
+          })
+        )
+      }
+      function Z5(u, i, c = 4, f = 4) {
+        let r = Math.max(f, i.left)
+        r + u.width > window.innerWidth - f &&
+          (r = window.innerWidth - u.width - f)
+        let o = Math.max(0, i.bottom) + c
+        return (
+          o + u.height > window.innerHeight - c &&
+            (Math.max(0, i.top) > u.height + c
+              ? (o = Math.max(0, i.top) - u.height - c)
+              : (o = window.innerHeight - c - u.height)),
+          { left: r, top: o }
+        )
+      }
+      function q5() {
+        if (document.playwrightThemeInitialized) return
+        ;((document.playwrightThemeInitialized = !0),
+          document.defaultView.addEventListener(
+            'focus',
+            (f) => {
+              f.target.document.nodeType === Node.DOCUMENT_NODE &&
+                document.body.classList.remove('inactive')
+            },
+            !1,
+          ),
+          document.defaultView.addEventListener(
+            'blur',
+            (f) => {
+              document.body.classList.add('inactive')
+            },
+            !1,
+          ))
+        const i = window.matchMedia('(prefers-color-scheme: dark)').matches
+          ? 'dark-mode'
+          : 'light-mode'
+        xa.getString('theme', i) === 'dark-mode'
+          ? document.documentElement.classList.add('dark-mode')
+          : document.documentElement.classList.add('light-mode')
+      }
+      const k5 = new Set()
+      function K5() {
+        const u = _f(),
+          i = u === 'dark-mode' ? 'light-mode' : 'dark-mode'
+        ;(document.documentElement.classList.remove(u),
+          document.documentElement.classList.add(i),
+          xa.setString('theme', i))
+        for (const c of k5) c(i)
+      }
+      function _f() {
+        return document.documentElement.classList.contains('dark-mode')
+          ? 'dark-mode'
+          : 'light-mode'
+      }
+      function W5() {
+        const [u, i] = ie.useState(_f() === 'dark-mode')
+        return [
+          u,
+          (c) => {
+            ;((_f() === 'dark-mode') !== c && K5(), i(c))
+          },
+        ]
+      }
+      const Ar = ({ title: u, leftSuperHeader: i, rightSuperHeader: c }) =>
+          m.jsxs('div', {
+            className: 'header-view',
+            children: [
+              m.jsxs('div', {
+                className: 'hbox header-superheader',
+                children: [i, m.jsx('div', { style: { flex: 'auto' } }), c],
+              }),
+              u && m.jsx('div', { className: 'header-title', children: Ri(u) }),
+            ],
+          }),
+        F5 = ({ stats: u, filterText: i, setFilterText: c }) => {
+          const r = ue().get('q')
+          return (
+            ct.useEffect(() => {
+              c(r ? `${r.trim()} ` : '')
+            }, [r, c]),
+            m.jsx(m.Fragment, {
+              children: m.jsxs('div', {
+                className: 'pt-3',
+                children: [
+                  m.jsx('div', {
+                    className: 'header-view-status-container ml-2 pl-2 d-flex',
+                    children: m.jsx(J5, { stats: u }),
+                  }),
+                  m.jsxs('form', {
+                    className: 'subnav-search',
+                    onSubmit: (o) => {
+                      o.preventDefault()
+                      const d = new URL(window.location.href),
+                        y = new URLSearchParams(d.hash.slice(1)),
+                        v = new FormData(o.target).get('q'),
+                        A = new URLSearchParams({ q: v })
+                      ;(y.has('speedboard') && A.set('speedboard', ''),
+                        A.toString() && (d.hash = '?' + A.toString()),
+                        _n(d))
+                    },
+                    children: [
+                      S5(),
+                      m.jsx('input', {
+                        name: 'q',
+                        spellCheck: !1,
+                        className:
+                          'form-control subnav-search-input input-contrast width-full',
+                        value: i,
+                        onChange: (o) => {
+                          c(o.target.value)
+                        },
+                      }),
+                    ],
+                  }),
+                ],
+              }),
+            })
+          )
+        },
+        J5 = ({ stats: u }) => {
+          const i = ue()
+          return m.jsxs('nav', {
+            children: [
+              m.jsxs(yn, {
+                className: 'subnav-item',
+                href: '#?',
+                children: [
+                  m.jsx('span', {
+                    className: 'subnav-item-label',
+                    children: 'All',
+                  }),
+                  m.jsx('span', {
+                    className: 'd-inline counter',
+                    children: u.total - u.skipped,
+                  }),
+                ],
+              }),
+              m.jsx(Pu, { token: 'passed', count: u.expected }),
+              m.jsx(Pu, { token: 'failed', count: u.unexpected }),
+              m.jsx(Pu, { token: 'flaky', count: u.flaky }),
+              m.jsx(Pu, { token: 'skipped', count: u.skipped }),
+              m.jsx(yn, {
+                className: 'subnav-item',
+                href: '#?speedboard',
+                title: 'Speedboard',
+                'aria-selected': i.has('speedboard'),
+                children: Hh(),
+              }),
+              m.jsx(P5, {}),
+            ],
+          })
+        },
+        Pu = ({ token: u, count: i }) => {
+          const c = ue()
+          ;(c.delete('speedboard'), c.delete('testId'))
+          const f = `s:${u}`,
+            r = wa(c, f, !1),
+            o = wa(c, f, !0),
+            d = u.charAt(0).toUpperCase() + u.slice(1)
+          return m.jsxs(yn, {
+            className: 'subnav-item',
+            href: r,
+            click: r,
+            ctrlClick: o,
+            children: [
+              i > 0 && cc(u),
+              m.jsx('span', { className: 'subnav-item-label', children: d }),
+              m.jsx('span', { className: 'd-inline counter', children: i }),
+            ],
+          })
+        },
+        P5 = () => {
+          const u = ct.useRef(null),
+            [i, c] = ct.useState(!1),
+            [f, r] = W5(),
+            [o, d] = Uh('mergeFiles', !1)
+          return m.jsx(m.Fragment, {
+            children: m.jsxs('div', {
+              role: 'button',
+              ref: u,
+              style: { cursor: 'pointer' },
+              className: 'subnav-item',
+              title: 'Settings',
+              onClick: (y) => {
+                ;(c(!i), y.preventDefault())
+              },
+              onMouseDown: _5,
+              children: [
+                C5(),
+                m.jsxs(I5, {
+                  open: i,
+                  minWidth: 150,
+                  verticalOffset: 4,
+                  requestClose: () => c(!1),
+                  anchor: u,
+                  dataTestId: 'settings-dialog',
+                  children: [
+                    m.jsxs('label', {
+                      style: {
+                        cursor: 'pointer',
+                        display: 'flex',
+                        alignItems: 'center',
+                        gap: 4,
+                      },
+                      onClick: y2,
+                      children: [
+                        m.jsx('input', {
+                          type: 'checkbox',
+                          checked: f,
+                          onChange: () => r(!f),
+                        }),
+                        'Dark mode',
+                      ],
+                    }),
+                    m.jsxs('label', {
+                      style: {
+                        cursor: 'pointer',
+                        display: 'flex',
+                        alignItems: 'center',
+                        gap: 4,
+                      },
+                      onClick: y2,
+                      children: [
+                        m.jsx('input', {
+                          type: 'checkbox',
+                          checked: o,
+                          onChange: () => d(!o),
+                        }),
+                        'Merge files',
+                      ],
+                    }),
+                  ],
+                }),
+              ],
+            }),
+          })
+        },
+        _5 = (u) => {
+          ;(u.stopPropagation(), u.preventDefault())
+        },
+        y2 = (u) => {
+          ;(u.stopPropagation(), u.stopImmediatePropagation())
+        },
+        $5 = ({ tabs: u, selectedTab: i, setSelectedTab: c }) => {
+          const f = ct.useId()
+          return m.jsx('div', {
+            className: 'tabbed-pane',
+            children: m.jsxs('div', {
+              className: 'vbox',
+              children: [
+                m.jsx('div', {
+                  className: 'hbox',
+                  style: { flex: 'none' },
+                  children: m.jsx('div', {
+                    className: 'tabbed-pane-tab-strip',
+                    role: 'tablist',
+                    children: u.map((r) =>
+                      m.jsx(
+                        'div',
+                        {
+                          className: Ye(
+                            'tabbed-pane-tab-element',
+                            i === r.id && 'selected',
+                          ),
+                          onClick: () => c(r.id),
+                          id: `${f}-${r.id}`,
+                          role: 'tab',
+                          'aria-selected': i === r.id,
+                          children: m.jsx('div', {
+                            className: 'tabbed-pane-tab-label',
+                            children: r.title,
+                          }),
+                        },
+                        r.id,
+                      ),
+                    ),
+                  }),
+                }),
+                u.map((r) => {
+                  if (i === r.id)
+                    return m.jsx(
+                      'div',
+                      {
+                        className: 'tab-content',
+                        role: 'tabpanel',
+                        'aria-labelledby': `${f}-${r.id}`,
+                        children: r.render(),
+                      },
+                      r.id,
+                    )
+                }),
+              ],
+            }),
+          })
+        },
+        Xh = ({
+          header: u,
+          footer: i,
+          expanded: c,
+          setExpanded: f,
+          children: r,
+          noInsets: o,
+          dataTestId: d,
+        }) => {
+          const y = ct.useId()
+          return m.jsxs('div', {
+            className: 'chip',
+            'data-testid': d,
+            children: [
+              m.jsxs('div', {
+                role: 'button',
+                'aria-expanded': !!c,
+                'aria-controls': y,
+                className: Ye('chip-header', f && ' expanded-' + c),
+                onClick: () => (f == null ? void 0 : f(!c)),
+                title: typeof u == 'string' ? u : void 0,
+                children: [
+                  f ? (c ? m.jsx(Mi, {}) : m.jsx(vl, {})) : m.jsx(x5, {}),
+                  u,
+                ],
+              }),
+              (!f || c) &&
+                m.jsxs('div', {
+                  id: y,
+                  role: 'region',
+                  className: Ye('chip-body', o && 'chip-body-no-insets'),
+                  children: [
+                    r,
+                    i &&
+                      m.jsx('div', { className: 'chip-footer', children: i }),
+                  ],
+                }),
+            ],
+          })
+        },
+        Ke = ({
+          header: u,
+          initialExpanded: i,
+          noInsets: c,
+          children: f,
+          dataTestId: r,
+          revealOnAnchorId: o,
+        }) => {
+          const [d, y] = ct.useState(i ?? !0),
+            v = ct.useCallback(() => y(!0), [])
+          return (
+            mr(o, v),
+            m.jsx(Xh, {
+              header: u,
+              expanded: d,
+              setExpanded: y,
+              noInsets: c,
+              dataTestId: r,
+              children: f,
+            })
+          )
+        },
+        tv = ({
+          title: u,
+          loadChildren: i,
+          onClick: c,
+          expandByDefault: f,
+          depth: r,
+          style: o,
+          flash: d,
+        }) => {
+          const [y, v] = ct.useState(f || !1)
+          return m.jsxs('div', {
+            role: 'treeitem',
+            className: Ye('tree-item', d && 'yellow-flash'),
+            style: o,
+            children: [
+              m.jsxs('span', {
+                className: 'tree-item-title',
+                style: { whiteSpace: 'nowrap', paddingLeft: r * 22 + 4 },
+                onClick: () => {
+                  ;(c == null || c(), v(!y))
+                },
+                children: [
+                  i && !!y && Mi(),
+                  i && !y && vl(),
+                  !i &&
+                    m.jsx('span', {
+                      style: { visibility: 'hidden' },
+                      children: vl(),
+                    }),
+                  u,
+                ],
+              }),
+              y && (i == null ? void 0 : i()),
+            ],
+          })
+        },
+        ev =
+          'data:image/png;base64,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',
+        nv = ({
+          cursor: u,
+          onPaneMouseMove: i,
+          onPaneMouseUp: c,
+          onPaneDoubleClick: f,
+        }) => (
+          ie.useEffect(() => {
+            const r = document.createElement('div')
+            return (
+              (r.style.position = 'fixed'),
+              (r.style.top = '0'),
+              (r.style.right = '0'),
+              (r.style.bottom = '0'),
+              (r.style.left = '0'),
+              (r.style.zIndex = '9999'),
+              (r.style.cursor = u),
+              document.body.appendChild(r),
+              i && r.addEventListener('mousemove', i),
+              c && r.addEventListener('mouseup', c),
+              f && document.body.addEventListener('dblclick', f),
+              () => {
+                ;(i && r.removeEventListener('mousemove', i),
+                  c && r.removeEventListener('mouseup', c),
+                  f && document.body.removeEventListener('dblclick', f),
+                  document.body.removeChild(r))
+              }
+            )
+          }, [u, i, c, f]),
+          m.jsx(m.Fragment, {})
+        ),
+        av = { position: 'absolute', top: 0, right: 0, bottom: 0, left: 0 },
+        lv = ({
+          orientation: u,
+          offsets: i,
+          setOffsets: c,
+          resizerColor: f,
+          resizerWidth: r,
+          minColumnWidth: o,
+        }) => {
+          const d = o || 0,
+            [y, v] = ie.useState(null),
+            [A, E] = Bh(),
+            w = {
+              position: 'absolute',
+              right: u === 'horizontal' ? void 0 : 0,
+              bottom: u === 'horizontal' ? 0 : void 0,
+              width: u === 'horizontal' ? 7 : void 0,
+              height: u === 'horizontal' ? void 0 : 7,
+              borderTopWidth: u === 'horizontal' ? void 0 : (7 - r) / 2,
+              borderRightWidth: u === 'horizontal' ? (7 - r) / 2 : void 0,
+              borderBottomWidth: u === 'horizontal' ? void 0 : (7 - r) / 2,
+              borderLeftWidth: u === 'horizontal' ? (7 - r) / 2 : void 0,
+              borderColor: 'transparent',
+              borderStyle: 'solid',
+              cursor: u === 'horizontal' ? 'ew-resize' : 'ns-resize',
+            }
+          return m.jsxs('div', {
+            style: {
+              position: 'absolute',
+              top: 0,
+              right: 0,
+              bottom: 0,
+              left: -(7 - r) / 2,
+              zIndex: 100,
+              pointerEvents: 'none',
+            },
+            ref: E,
+            children: [
+              !!y &&
+                m.jsx(nv, {
+                  cursor: u === 'horizontal' ? 'ew-resize' : 'ns-resize',
+                  onPaneMouseUp: () => v(null),
+                  onPaneMouseMove: (R) => {
+                    if (!R.buttons) v(null)
+                    else if (y) {
+                      const z =
+                          u === 'horizontal'
+                            ? R.clientX - y.clientX
+                            : R.clientY - y.clientY,
+                        N = y.offset + z,
+                        x = y.index > 0 ? i[y.index - 1] : 0,
+                        p = u === 'horizontal' ? A.width : A.height,
+                        T = Math.min(Math.max(x + d, N), p - d) - i[y.index]
+                      for (let D = y.index; D < i.length; ++D) i[D] = i[D] + T
+                      c([...i])
+                    }
+                  },
+                }),
+              i.map((R, z) =>
+                m.jsx(
+                  'div',
+                  {
+                    style: {
+                      ...w,
+                      top: u === 'horizontal' ? 0 : R,
+                      left: u === 'horizontal' ? R : 0,
+                      pointerEvents: 'initial',
+                    },
+                    onMouseDown: (N) =>
+                      v({
+                        clientX: N.clientX,
+                        clientY: N.clientY,
+                        offset: R,
+                        index: z,
+                      }),
+                    children: m.jsx('div', { style: { ...av, background: f } }),
+                  },
+                  z,
+                ),
+              ),
+            ],
+          })
+        }
+      async function Lf(u) {
+        const i = new Image()
+        return (
+          u &&
+            ((i.src = u),
+            await new Promise((c, f) => {
+              ;((i.onload = c), (i.onerror = c))
+            })),
+          i
+        )
+      }
+      const $f = {
+          backgroundImage: `linear-gradient(45deg, #80808020 25%, transparent 25%),
+                    linear-gradient(-45deg, #80808020 25%, transparent 25%),
+                    linear-gradient(45deg, transparent 75%, #80808020 75%),
+                    linear-gradient(-45deg, transparent 75%, #80808020 75%)`,
+          backgroundSize: '20px 20px',
+          backgroundPosition: '0 0, 0 10px, 10px -10px, -10px 0px',
+          boxShadow: `rgb(0 0 0 / 10%) 0px 1.8px 1.9px,
+              rgb(0 0 0 / 15%) 0px 6.1px 6.3px,
+              rgb(0 0 0 / 10%) 0px -2px 4px,
+              rgb(0 0 0 / 15%) 0px -6.1px 12px,
+              rgb(0 0 0 / 25%) 0px 6px 12px`,
+        },
+        Vh = ({ diff: u, noTargetBlank: i, hideDetails: c }) => {
+          const [f, r] = ct.useState(u.diff ? 'diff' : 'actual'),
+            [o, d] = ct.useState(!1),
+            [y, v] = ct.useState(null),
+            [A, E] = ct.useState('Expected'),
+            [w, R] = ct.useState(null),
+            [z, N] = ct.useState(null),
+            [x, p] = Bh()
+          ct.useEffect(() => {
+            ;(async () => {
+              var W, F, K, et
+              ;(v(
+                await Lf((W = u.expected) == null ? void 0 : W.attachment.path),
+              ),
+                E(((F = u.expected) == null ? void 0 : F.title) || 'Expected'),
+                R(
+                  await Lf((K = u.actual) == null ? void 0 : K.attachment.path),
+                ),
+                N(
+                  await Lf((et = u.diff) == null ? void 0 : et.attachment.path),
+                ))
+            })()
+          }, [u])
+          const T = y && w && z,
+            D = T ? Math.max(y.naturalWidth, w.naturalWidth, 200) : 500,
+            U = T ? Math.max(y.naturalHeight, w.naturalHeight, 200) : 500,
+            I = Math.min(1, (x.width - 30) / D),
+            V = Math.min(1, (x.width - 50) / D / 2),
+            j = D * I,
+            G = U * I,
+            L = {
+              flex: 'none',
+              margin: '0 10px',
+              cursor: 'pointer',
+              userSelect: 'none',
+            }
+          return m.jsx('div', {
+            'data-testid': 'test-result-image-mismatch',
+            style: {
+              display: 'flex',
+              flexDirection: 'column',
+              alignItems: 'center',
+              flex: 'auto',
+            },
+            ref: p,
+            children:
+              T &&
+              m.jsxs(m.Fragment, {
+                children: [
+                  m.jsxs('div', {
+                    'data-testid': 'test-result-image-mismatch-tabs',
+                    style: { display: 'flex', margin: '10px 0 20px' },
+                    children: [
+                      u.diff &&
+                        m.jsx('div', {
+                          style: {
+                            ...L,
+                            fontWeight: f === 'diff' ? 600 : 'initial',
+                          },
+                          onClick: () => r('diff'),
+                          children: 'Diff',
+                        }),
+                      m.jsx('div', {
+                        style: {
+                          ...L,
+                          fontWeight: f === 'actual' ? 600 : 'initial',
+                        },
+                        onClick: () => r('actual'),
+                        children: 'Actual',
+                      }),
+                      m.jsx('div', {
+                        style: {
+                          ...L,
+                          fontWeight: f === 'expected' ? 600 : 'initial',
+                        },
+                        onClick: () => r('expected'),
+                        children: A,
+                      }),
+                      m.jsx('div', {
+                        style: {
+                          ...L,
+                          fontWeight: f === 'sxs' ? 600 : 'initial',
+                        },
+                        onClick: () => r('sxs'),
+                        children: 'Side by side',
+                      }),
+                      m.jsx('div', {
+                        style: {
+                          ...L,
+                          fontWeight: f === 'slider' ? 600 : 'initial',
+                        },
+                        onClick: () => r('slider'),
+                        children: 'Slider',
+                      }),
+                    ],
+                  }),
+                  m.jsxs('div', {
+                    style: {
+                      display: 'flex',
+                      justifyContent: 'center',
+                      flex: 'auto',
+                      minHeight: G + 60,
+                    },
+                    children: [
+                      u.diff &&
+                        f === 'diff' &&
+                        m.jsx(hn, {
+                          image: z,
+                          alt: 'Diff',
+                          hideSize: c,
+                          canvasWidth: j,
+                          canvasHeight: G,
+                          scale: I,
+                        }),
+                      u.diff &&
+                        f === 'actual' &&
+                        m.jsx(hn, {
+                          image: w,
+                          alt: 'Actual',
+                          hideSize: c,
+                          canvasWidth: j,
+                          canvasHeight: G,
+                          scale: I,
+                        }),
+                      u.diff &&
+                        f === 'expected' &&
+                        m.jsx(hn, {
+                          image: y,
+                          alt: A,
+                          hideSize: c,
+                          canvasWidth: j,
+                          canvasHeight: G,
+                          scale: I,
+                        }),
+                      u.diff &&
+                        f === 'slider' &&
+                        m.jsx(iv, {
+                          expectedImage: y,
+                          actualImage: w,
+                          hideSize: c,
+                          canvasWidth: j,
+                          canvasHeight: G,
+                          scale: I,
+                          expectedTitle: A,
+                        }),
+                      u.diff &&
+                        f === 'sxs' &&
+                        m.jsxs('div', {
+                          style: { display: 'flex' },
+                          children: [
+                            m.jsx(hn, {
+                              image: y,
+                              title: A,
+                              hideSize: c,
+                              canvasWidth: V * D,
+                              canvasHeight: V * U,
+                              scale: V,
+                            }),
+                            m.jsx(hn, {
+                              image: o ? z : w,
+                              title: o ? 'Diff' : 'Actual',
+                              onClick: () => d(!o),
+                              hideSize: c,
+                              canvasWidth: V * D,
+                              canvasHeight: V * U,
+                              scale: V,
+                            }),
+                          ],
+                        }),
+                      !u.diff &&
+                        f === 'actual' &&
+                        m.jsx(hn, {
+                          image: w,
+                          title: 'Actual',
+                          hideSize: c,
+                          canvasWidth: j,
+                          canvasHeight: G,
+                          scale: I,
+                        }),
+                      !u.diff &&
+                        f === 'expected' &&
+                        m.jsx(hn, {
+                          image: y,
+                          title: A,
+                          hideSize: c,
+                          canvasWidth: j,
+                          canvasHeight: G,
+                          scale: I,
+                        }),
+                      !u.diff &&
+                        f === 'sxs' &&
+                        m.jsxs('div', {
+                          style: { display: 'flex' },
+                          children: [
+                            m.jsx(hn, {
+                              image: y,
+                              title: A,
+                              canvasWidth: V * D,
+                              canvasHeight: V * U,
+                              scale: V,
+                            }),
+                            m.jsx(hn, {
+                              image: w,
+                              title: 'Actual',
+                              canvasWidth: V * D,
+                              canvasHeight: V * U,
+                              scale: V,
+                            }),
+                          ],
+                        }),
+                    ],
+                  }),
+                  !c &&
+                    m.jsxs('div', {
+                      style: {
+                        alignSelf: 'start',
+                        lineHeight: '18px',
+                        marginLeft: '15px',
+                      },
+                      children: [
+                        m.jsx('div', {
+                          children:
+                            u.diff &&
+                            m.jsx('a', {
+                              target: '_blank',
+                              href: u.diff.attachment.path,
+                              rel: 'noreferrer',
+                              children: u.diff.attachment.name,
+                            }),
+                        }),
+                        m.jsx('div', {
+                          children: m.jsx('a', {
+                            target: i ? '' : '_blank',
+                            href: u.actual.attachment.path,
+                            rel: 'noreferrer',
+                            children: u.actual.attachment.name,
+                          }),
+                        }),
+                        m.jsx('div', {
+                          children: m.jsx('a', {
+                            target: i ? '' : '_blank',
+                            href: u.expected.attachment.path,
+                            rel: 'noreferrer',
+                            children: u.expected.attachment.name,
+                          }),
+                        }),
+                      ],
+                    }),
+                ],
+              }),
+          })
+        },
+        iv = ({
+          expectedImage: u,
+          actualImage: i,
+          canvasWidth: c,
+          canvasHeight: f,
+          scale: r,
+          expectedTitle: o,
+          hideSize: d,
+        }) => {
+          const y = { position: 'absolute', top: 0, left: 0 },
+            [v, A] = ct.useState(c / 2),
+            E =
+              u.naturalWidth === i.naturalWidth &&
+              u.naturalHeight === i.naturalHeight
+          return m.jsxs('div', {
+            style: {
+              flex: 'none',
+              display: 'flex',
+              alignItems: 'center',
+              flexDirection: 'column',
+              userSelect: 'none',
+            },
+            children: [
+              !d &&
+                m.jsxs('div', {
+                  style: { margin: 5 },
+                  children: [
+                    !E &&
+                      m.jsx('span', {
+                        style: { flex: 'none', margin: '0 5px' },
+                        children: 'Expected ',
+                      }),
+                    m.jsx('span', { children: u.naturalWidth }),
+                    m.jsx('span', {
+                      style: { flex: 'none', margin: '0 5px' },
+                      children: 'x',
+                    }),
+                    m.jsx('span', { children: u.naturalHeight }),
+                    !E &&
+                      m.jsx('span', {
+                        style: { flex: 'none', margin: '0 5px 0 15px' },
+                        children: 'Actual ',
+                      }),
+                    !E && m.jsx('span', { children: i.naturalWidth }),
+                    !E &&
+                      m.jsx('span', {
+                        style: { flex: 'none', margin: '0 5px' },
+                        children: 'x',
+                      }),
+                    !E && m.jsx('span', { children: i.naturalHeight }),
+                  ],
+                }),
+              m.jsxs('div', {
+                style: {
+                  position: 'relative',
+                  width: c,
+                  height: f,
+                  margin: 15,
+                  ...$f,
+                },
+                children: [
+                  m.jsx(lv, {
+                    orientation: 'horizontal',
+                    offsets: [v],
+                    setOffsets: (w) => A(w[0]),
+                    resizerColor: '#57606a80',
+                    resizerWidth: 6,
+                  }),
+                  m.jsx('img', {
+                    alt: o,
+                    style: {
+                      width: u.naturalWidth * r,
+                      height: u.naturalHeight * r,
+                    },
+                    draggable: 'false',
+                    src: u.src,
+                  }),
+                  m.jsx('div', {
+                    style: {
+                      ...y,
+                      bottom: 0,
+                      overflow: 'hidden',
+                      width: v,
+                      ...$f,
+                    },
+                    children: m.jsx('img', {
+                      alt: 'Actual',
+                      style: {
+                        width: i.naturalWidth * r,
+                        height: i.naturalHeight * r,
+                      },
+                      draggable: 'false',
+                      src: i.src,
+                    }),
+                  }),
+                ],
+              }),
+            ],
+          })
+        },
+        hn = ({
+          image: u,
+          title: i,
+          alt: c,
+          hideSize: f,
+          canvasWidth: r,
+          canvasHeight: o,
+          scale: d,
+          onClick: y,
+        }) =>
+          m.jsxs('div', {
+            style: {
+              flex: 'none',
+              display: 'flex',
+              alignItems: 'center',
+              flexDirection: 'column',
+            },
+            children: [
+              !f &&
+                m.jsxs('div', {
+                  style: { margin: 5 },
+                  children: [
+                    i &&
+                      m.jsx('span', {
+                        style: { flex: 'none', margin: '0 5px' },
+                        children: i,
+                      }),
+                    m.jsx('span', { children: u.naturalWidth }),
+                    m.jsx('span', {
+                      style: { flex: 'none', margin: '0 5px' },
+                      children: 'x',
+                    }),
+                    m.jsx('span', { children: u.naturalHeight }),
+                  ],
+                }),
+              m.jsx('div', {
+                style: {
+                  display: 'flex',
+                  flex: 'none',
+                  width: r,
+                  height: o,
+                  margin: 15,
+                  ...$f,
+                },
+                children: m.jsx('img', {
+                  width: u.naturalWidth * d,
+                  height: u.naturalHeight * d,
+                  alt: i || c,
+                  style: { cursor: y ? 'pointer' : 'initial' },
+                  draggable: 'false',
+                  src: u.src,
+                  onClick: y,
+                }),
+              }),
+            ],
+          })
+      function uv(u, i) {
+        const c = /(\x1b\[(\d+(;\d+)*)m)|([^\x1b]+)/g,
+          f = []
+        let r,
+          o = {},
+          d = !1,
+          y = i == null ? void 0 : i.fg,
+          v = i == null ? void 0 : i.bg
+        for (; (r = c.exec(u)) !== null; ) {
+          const [, , A, , E] = r
+          if (A) {
+            const w = +A
+            switch (w) {
+              case 0:
+                o = {}
+                break
+              case 1:
+                o['font-weight'] = 'bold'
+                break
+              case 2:
+                o.opacity = '0.8'
+                break
+              case 3:
+                o['font-style'] = 'italic'
+                break
+              case 4:
+                o['text-decoration'] = 'underline'
+                break
+              case 7:
+                d = !0
+                break
+              case 8:
+                o.display = 'none'
+                break
+              case 9:
+                o['text-decoration'] = 'line-through'
+                break
+              case 22:
+                ;(delete o['font-weight'],
+                  delete o['font-style'],
+                  delete o.opacity,
+                  delete o['text-decoration'])
+                break
+              case 23:
+                ;(delete o['font-weight'],
+                  delete o['font-style'],
+                  delete o.opacity)
+                break
+              case 24:
+                delete o['text-decoration']
+                break
+              case 27:
+                d = !1
+                break
+              case 30:
+              case 31:
+              case 32:
+              case 33:
+              case 34:
+              case 35:
+              case 36:
+              case 37:
+                y = E2[w - 30]
+                break
+              case 39:
+                y = i == null ? void 0 : i.fg
+                break
+              case 40:
+              case 41:
+              case 42:
+              case 43:
+              case 44:
+              case 45:
+              case 46:
+              case 47:
+                v = E2[w - 40]
+                break
+              case 49:
+                v = i == null ? void 0 : i.bg
+                break
+              case 53:
+                o['text-decoration'] = 'overline'
+                break
+              case 90:
+              case 91:
+              case 92:
+              case 93:
+              case 94:
+              case 95:
+              case 96:
+              case 97:
+                y = b2[w - 90]
+                break
+              case 100:
+              case 101:
+              case 102:
+              case 103:
+              case 104:
+              case 105:
+              case 106:
+              case 107:
+                v = b2[w - 100]
+                break
+            }
+          } else if (E) {
+            const w = { ...o },
+              R = d ? v : y
+            R !== void 0 && (w.color = R)
+            const z = d ? y : v
+            ;(z !== void 0 && (w['background-color'] = z),
+              f.push(`<span style="${sv(w)}">${cv(E)}</span>`))
+          }
+        }
+        return f.join('')
+      }
+      const E2 = {
+          0: 'var(--vscode-terminal-ansiBlack)',
+          1: 'var(--vscode-terminal-ansiRed)',
+          2: 'var(--vscode-terminal-ansiGreen)',
+          3: 'var(--vscode-terminal-ansiYellow)',
+          4: 'var(--vscode-terminal-ansiBlue)',
+          5: 'var(--vscode-terminal-ansiMagenta)',
+          6: 'var(--vscode-terminal-ansiCyan)',
+          7: 'var(--vscode-terminal-ansiWhite)',
+        },
+        b2 = {
+          0: 'var(--vscode-terminal-ansiBrightBlack)',
+          1: 'var(--vscode-terminal-ansiBrightRed)',
+          2: 'var(--vscode-terminal-ansiBrightGreen)',
+          3: 'var(--vscode-terminal-ansiBrightYellow)',
+          4: 'var(--vscode-terminal-ansiBrightBlue)',
+          5: 'var(--vscode-terminal-ansiBrightMagenta)',
+          6: 'var(--vscode-terminal-ansiBrightCyan)',
+          7: 'var(--vscode-terminal-ansiBrightWhite)',
+        }
+      function cv(u) {
+        return u.replace(
+          /[&"<>]/g,
+          (i) => ({ '&': '&amp;', '"': '&quot;', '<': '&lt;', '>': '&gt;' })[i],
+        )
+      }
+      function sv(u) {
+        return Object.entries(u)
+          .map(([i, c]) => `${i}: ${c}`)
+          .join('; ')
+      }
+      const vr = ({ code: u, children: i, testId: c }) => {
+          const f = ct.useMemo(() => ov(u), [u])
+          return m.jsxs('div', {
+            className: 'test-error-container test-error-text',
+            'data-testid': c,
+            children: [
+              i,
+              m.jsx('div', {
+                className: 'test-error-view',
+                dangerouslySetInnerHTML: { __html: f || '' },
+              }),
+            ],
+          })
+        },
+        fv = ({ prompt: u }) => {
+          const [i, c] = ct.useState(!1)
+          return m.jsx('button', {
+            className: 'button',
+            style: { minWidth: 100 },
+            onClick: async () => {
+              ;(await navigator.clipboard.writeText(u),
+                c(!0),
+                setTimeout(() => {
+                  c(!1)
+                }, 3e3))
+            },
+            children: i ? 'Copied' : 'Copy prompt',
+          })
+        },
+        rv = ({ diff: u }) =>
+          m.jsx('div', {
+            'data-testid': 'test-screenshot-error-view',
+            className: 'test-error-view',
+            children: m.jsx(Vh, { diff: u, hideDetails: !0 }, 'image-diff'),
+          })
+      function ov(u) {
+        return uv(u || '', {
+          bg: 'var(--color-canvas-subtle)',
+          fg: 'var(--color-fg-default)',
+        })
+      }
+      const dv = `
+# Instructions
+
+- Following Playwright test failed.
+- Explain why, be concise, respect Playwright best practices.
+- Provide a snippet of code with the fix, if possible.
+`.trimStart()
+      async function hv({
+        testInfo: u,
+        metadata: i,
+        errorContext: c,
+        errors: f,
+        buildCodeFrame: r,
+        stdout: o,
+        stderr: d,
+      }) {
+        var w
+        const y = new Set(
+          f
+            .filter(
+              (R) =>
+                R.message &&
+                !R.message.includes(`
+`),
+            )
+            .map((R) => R.message),
+        )
+        for (const R of f)
+          for (const z of y.keys())
+            (w = R.message) != null && w.includes(z) && y.delete(z)
+        const v = f.filter(
+          (R) =>
+            !(
+              !R.message ||
+              (!R.message.includes(`
+`) &&
+                !y.has(R.message))
+            ),
+        )
+        if (!v.length) return
+        const A = [dv, '# Test info', '', u]
+        ;(o && A.push('', '# Stdout', '', '```', zf(o), '```'),
+          d && A.push('', '# Stderr', '', '```', zf(d), '```'),
+          A.push('', '# Error details'))
+        for (const R of v) A.push('', '```', zf(R.message || ''), '```')
+        c && A.push(c)
+        const E = await r(v[v.length - 1])
+        return (
+          E && A.push('', '# Test source', '', '```ts', E, '```'),
+          i != null &&
+            i.gitDiff &&
+            A.push('', '# Local changes', '', '```diff', i.gitDiff, '```'),
+          A.join(`
+`)
+        )
+      }
+      const gv = new RegExp(
+        '([\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~])))',
+        'g',
+      )
+      function zf(u) {
+        return u.replace(gv, '')
+      }
+      function mv(u, i) {
+        var f
+        const c = new Map()
+        for (const r of u) {
+          const o = r.name.match(
+            /^(.*)-(expected|actual|diff|previous)(\.[^.]+)?$/,
+          )
+          if (!o) continue
+          const [, d, y, v = ''] = o,
+            A = d + v
+          let E = c.get(A)
+          ;(E || ((E = { name: A, anchors: [`attachment-${d}`] }), c.set(A, E)),
+            E.anchors.push(`attachment-${i.attachments.indexOf(r)}`),
+            y === 'actual' && (E.actual = { attachment: r }),
+            y === 'expected' &&
+              (E.expected = { attachment: r, title: 'Expected' }),
+            y === 'previous' &&
+              (E.expected = { attachment: r, title: 'Previous' }),
+            y === 'diff' && (E.diff = { attachment: r }))
+        }
+        for (const [r, o] of c)
+          !o.actual || !o.expected
+            ? c.delete(r)
+            : (u.delete(o.actual.attachment),
+              u.delete(o.expected.attachment),
+              u.delete((f = o.diff) == null ? void 0 : f.attachment))
+        return [...c.values()]
+      }
+      const Av = ({ test: u, result: i, testRunMetadata: c, options: f }) => {
+        const {
+            screenshots: r,
+            videos: o,
+            traces: d,
+            otherAttachments: y,
+            diffs: v,
+            errors: A,
+            otherAttachmentAnchors: E,
+            screenshotAnchors: w,
+            errorContext: R,
+          } = ct.useMemo(() => {
+            const N = i.attachments.filter((L) => !L.name.startsWith('_')),
+              x = new Set(N.filter((L) => L.contentType.startsWith('image/'))),
+              p = [...x].map((L) => `attachment-${N.indexOf(L)}`),
+              T = N.filter((L) => L.contentType.startsWith('video/')),
+              D = N.filter((L) => L.name === 'trace'),
+              U = N.find((L) => L.name === 'error-context'),
+              I = new Set(N)
+            ;[...x, ...T, ...D].forEach((L) => I.delete(L))
+            const V = [...I].map((L) => `attachment-${N.indexOf(L)}`),
+              j = mv(x, i),
+              G = i.errors.map((L) => L.message)
+            return {
+              screenshots: [...x],
+              videos: T,
+              traces: D,
+              otherAttachments: I,
+              diffs: j,
+              errors: G,
+              otherAttachmentAnchors: V,
+              screenshotAnchors: p,
+              errorContext: U,
+            }
+          }, [i]),
+          z = M5(
+            async () => {
+              if (f != null && f.noCopyPrompt) return
+              const N = i.attachments.find((D) => D.name === 'stdout'),
+                x = i.attachments.find((D) => D.name === 'stderr'),
+                p =
+                  N != null && N.body && N.contentType === 'text/plain'
+                    ? N.body
+                    : void 0,
+                T =
+                  x != null && x.body && x.contentType === 'text/plain'
+                    ? x.body
+                    : void 0
+              return await hv({
+                testInfo: [
+                  `- Name: ${u.path.join(' >> ')} >> ${u.title}`,
+                  `- Location: ${u.location.file}:${u.location.line}:${u.location.column}`,
+                ].join(`
+`),
+                metadata: c,
+                errorContext:
+                  R != null && R.path
+                    ? await fetch(R.path).then((D) => D.text())
+                    : R == null
+                      ? void 0
+                      : R.body,
+                errors: i.errors,
+                buildCodeFrame: async (D) => D.codeframe,
+                stdout: p,
+                stderr: T,
+              })
+            },
+            [u, R, c, i],
+            void 0,
+          )
+        return m.jsxs('div', {
+          className: 'test-result',
+          children: [
+            !!A.length &&
+              m.jsxs(Ke, {
+                header: 'Errors',
+                children: [
+                  z &&
+                    m.jsx('div', {
+                      style: {
+                        position: 'absolute',
+                        right: '16px',
+                        padding: '10px',
+                        zIndex: 1,
+                      },
+                      children: m.jsx(fv, { prompt: z }),
+                    }),
+                  A.map((N, x) => {
+                    const p = vv(N, v)
+                    return m.jsxs(m.Fragment, {
+                      children: [
+                        m.jsx(
+                          vr,
+                          { code: N },
+                          'test-result-error-message-' + x,
+                        ),
+                        p && m.jsx(rv, { diff: p }),
+                      ],
+                    })
+                  }),
+                ],
+              }),
+            !!i.steps.length &&
+              m.jsx(Ke, {
+                header: 'Test Steps',
+                children: i.steps.map((N, x) =>
+                  m.jsx(
+                    Ih,
+                    { step: N, result: i, test: u, depth: 0 },
+                    `step-${x}`,
+                  ),
+                ),
+              }),
+            v.map((N, x) =>
+              m.jsx(
+                bi,
+                {
+                  id: N.anchors,
+                  children: m.jsx(Ke, {
+                    dataTestId: 'test-results-image-diff',
+                    header: `Image mismatch: ${N.name}`,
+                    revealOnAnchorId: N.anchors,
+                    children: m.jsx(Vh, { diff: N }),
+                  }),
+                },
+                `diff-${x}`,
+              ),
+            ),
+            !!r.length &&
+              m.jsx(Ke, {
+                header: 'Screenshots',
+                revealOnAnchorId: w,
+                children: r.map((N, x) =>
+                  m.jsxs(
+                    bi,
+                    {
+                      id: `attachment-${i.attachments.indexOf(N)}`,
+                      children: [
+                        m.jsx('a', {
+                          href: Qe(N.path),
+                          children: m.jsx('img', {
+                            className: 'screenshot',
+                            src: Qe(N.path),
+                          }),
+                        }),
+                        m.jsx(Ju, { attachment: N, result: i }),
+                      ],
+                    },
+                    `screenshot-${x}`,
+                  ),
+                ),
+              }),
+            !!d.length &&
+              m.jsx(bi, {
+                id: 'attachment-trace',
+                children: m.jsx(Ke, {
+                  header: 'Traces',
+                  revealOnAnchorId: 'attachment-trace',
+                  children: m.jsxs('div', {
+                    children: [
+                      m.jsx('a', {
+                        href: Qe(Gh(d)),
+                        children: m.jsx('img', {
+                          className: 'screenshot',
+                          src: ev,
+                          style: { width: 192, height: 117, marginLeft: 20 },
+                        }),
+                      }),
+                      d.map((N, x) =>
+                        m.jsx(
+                          Ju,
+                          {
+                            attachment: N,
+                            result: i,
+                            linkName:
+                              d.length === 1 ? 'trace' : `trace-${x + 1}`,
+                          },
+                          `trace-${x}`,
+                        ),
+                      ),
+                    ],
+                  }),
+                }),
+              }),
+            !!o.length &&
+              m.jsx(bi, {
+                id: 'attachment-video',
+                children: m.jsx(Ke, {
+                  header: 'Videos',
+                  revealOnAnchorId: 'attachment-video',
+                  children: o.map((N) =>
+                    m.jsxs(
+                      'div',
+                      {
+                        children: [
+                          m.jsx('video', {
+                            controls: !0,
+                            children: m.jsx('source', {
+                              src: Qe(N.path),
+                              type: N.contentType,
+                            }),
+                          }),
+                          m.jsx(Ju, { attachment: N, result: i }),
+                        ],
+                      },
+                      N.path,
+                    ),
+                  ),
+                }),
+              }),
+            !!y.size &&
+              m.jsx(Ke, {
+                header: 'Attachments',
+                revealOnAnchorId: E,
+                dataTestId: 'attachments',
+                children: [...y].map((N, x) =>
+                  m.jsx(
+                    bi,
+                    {
+                      id: `attachment-${i.attachments.indexOf(N)}`,
+                      children: m.jsx(Ju, {
+                        attachment: N,
+                        result: i,
+                        openInNewTab: N.contentType.startsWith('text/html'),
+                      }),
+                    },
+                    `attachment-link-${x}`,
+                  ),
+                ),
+              }),
+          ],
+        })
+      }
+      function vv(u, i) {
+        const c = u.split(`
+`)[0]
+        if (
+          !(!c.includes('toHaveScreenshot') && !c.includes('toMatchSnapshot'))
+        )
+          return i.find((f) => u.includes(f.name))
+      }
+      const Ih = ({ test: u, step: i, result: c, depth: f }) => {
+          const r = ue()
+          return m.jsx(tv, {
+            title: m.jsxs('span', {
+              'aria-label': i.title,
+              children: [
+                m.jsx('span', {
+                  style: { float: 'right' },
+                  children: yl(i.duration),
+                }),
+                i.attachments.length > 0 &&
+                  m.jsx('a', {
+                    style: { float: 'right' },
+                    title: 'reveal attachment',
+                    href: Qe(
+                      En(
+                        {
+                          test: u,
+                          result: c,
+                          anchor: `attachment-${i.attachments[0]}`,
+                        },
+                        r,
+                      ),
+                    ),
+                    onClick: (o) => {
+                      o.stopPropagation()
+                    },
+                    children: Ch(),
+                  }),
+                cc(
+                  i.error || i.duration === -1
+                    ? 'failed'
+                    : i.skipped
+                      ? 'skipped'
+                      : 'passed',
+                ),
+                m.jsx('span', { children: i.title }),
+                i.count > 1 &&
+                  m.jsxs(m.Fragment, {
+                    children: [
+                      ' ✕ ',
+                      m.jsx('span', {
+                        className: 'test-result-counter',
+                        children: i.count,
+                      }),
+                    ],
+                  }),
+                i.location &&
+                  m.jsxs('span', {
+                    className: 'test-result-path',
+                    children: ['— ', i.location.file, ':', i.location.line],
+                  }),
+              ],
+            }),
+            loadChildren:
+              i.steps.length || i.snippet
+                ? () => {
+                    const o = i.snippet
+                        ? [
+                            m.jsx(
+                              vr,
+                              { testId: 'test-snippet', code: i.snippet },
+                              'line',
+                            ),
+                          ]
+                        : [],
+                      d = i.steps.map((y, v) =>
+                        m.jsx(
+                          Ih,
+                          { step: y, depth: f + 1, result: c, test: u },
+                          v,
+                        ),
+                      )
+                    return o.concat(d)
+                  }
+                : void 0,
+            depth: f,
+          })
+        },
+        yv = ({
+          projectNames: u,
+          test: i,
+          testRunMetadata: c,
+          run: f,
+          next: r,
+          prev: o,
+          options: d,
+        }) => {
+          const [y, v] = ct.useState(f),
+            A = ue(),
+            E = i.annotations.filter((w) => !w.type.startsWith('_')) ?? []
+          return m.jsxs(m.Fragment, {
+            children: [
+              m.jsx(Ar, {
+                title: i.title,
+                leftSuperHeader: m.jsx('div', {
+                  className: 'test-case-path',
+                  children: i.path.join(' › '),
+                }),
+                rightSuperHeader: m.jsxs(m.Fragment, {
+                  children: [
+                    m.jsx('div', {
+                      className: Ye(!o && 'hidden'),
+                      children: m.jsx(yn, {
+                        href: En({ test: o }, A),
+                        children: '« previous',
+                      }),
+                    }),
+                    m.jsx('div', { style: { width: 10 } }),
+                    m.jsx('div', {
+                      className: Ye(!r && 'hidden'),
+                      children: m.jsx(yn, {
+                        href: En({ test: r }, A),
+                        children: 'next »',
+                      }),
+                    }),
+                  ],
+                }),
+              }),
+              m.jsxs('div', {
+                className: 'hbox',
+                style: { lineHeight: '24px' },
+                children: [
+                  m.jsx('div', {
+                    className: 'test-case-location',
+                    children: m.jsxs(hr, {
+                      value: `${i.location.file}:${i.location.line}`,
+                      children: [i.location.file, ':', i.location.line],
+                    }),
+                  }),
+                  m.jsx('div', { style: { flex: 'auto' } }),
+                  m.jsx(Lh, { test: i, trailingSeparator: !0 }),
+                  m.jsx('div', {
+                    className: 'test-case-duration',
+                    children: yl(i.duration),
+                  }),
+                ],
+              }),
+              m.jsx(Yh, {
+                style: { marginLeft: '6px' },
+                projectNames: u,
+                activeProjectName: i.projectName,
+                otherLabels: i.tags,
+              }),
+              i.results.length === 0 &&
+                E.length !== 0 &&
+                m.jsx(Ke, {
+                  header: 'Annotations',
+                  dataTestId: 'test-case-annotations',
+                  children: E.map((w, R) => m.jsx(p2, { annotation: w }, R)),
+                }),
+              m.jsx($5, {
+                tabs:
+                  i.results.map((w, R) => ({
+                    id: String(R),
+                    title: m.jsxs('div', {
+                      style: { display: 'flex', alignItems: 'center' },
+                      children: [
+                        cc(w.status),
+                        ' ',
+                        Ev(R),
+                        i.results.length > 1 &&
+                          m.jsx('span', {
+                            className: 'test-case-run-duration',
+                            children: yl(w.duration),
+                          }),
+                      ],
+                    }),
+                    render: () => {
+                      const z = w.annotations.filter(
+                        (N) => !N.type.startsWith('_'),
+                      )
+                      return m.jsxs(m.Fragment, {
+                        children: [
+                          !!z.length &&
+                            m.jsx(Ke, {
+                              header: 'Annotations',
+                              dataTestId: 'test-case-annotations',
+                              children: z.map((N, x) =>
+                                m.jsx(p2, { annotation: N }, x),
+                              ),
+                            }),
+                          m.jsx(Av, {
+                            test: i,
+                            result: w,
+                            testRunMetadata: c,
+                            options: d,
+                          }),
+                        ],
+                      })
+                    },
+                  })) || [],
+                selectedTab: String(y),
+                setSelectedTab: (w) => v(+w),
+              }),
+            ],
+          })
+        }
+      function p2({ annotation: { type: u, description: i } }) {
+        return m.jsxs('div', {
+          className: 'test-case-annotation',
+          children: [
+            m.jsx('span', { style: { fontWeight: 'bold' }, children: u }),
+            i && m.jsxs(hr, { value: i, children: [': ', Ri(i)] }),
+          ],
+        })
+      }
+      function Ev(u) {
+        return u ? `Retry #${u}` : 'Run'
+      }
+      const Zh = ({
+        file: u,
+        projectNames: i,
+        isFileExpanded: c,
+        setFileExpanded: f,
+        footer: r,
+      }) => {
+        const o = ue()
+        return m.jsx(Xh, {
+          expanded: c ? c(u.fileId) : void 0,
+          noInsets: !0,
+          setExpanded: f ? (d) => f(u.fileId, d) : void 0,
+          header: m.jsx('span', {
+            className: 'chip-header-allow-selection',
+            children: u.fileName,
+          }),
+          footer: r,
+          children: u.tests.map((d) =>
+            m.jsxs(
+              'div',
+              {
+                className: Ye(
+                  'test-file-test',
+                  'test-file-test-outcome-' + d.outcome,
+                ),
+                children: [
+                  m.jsxs('div', {
+                    className: 'hbox',
+                    style: { alignItems: 'flex-start' },
+                    children: [
+                      m.jsxs('div', {
+                        className: 'hbox',
+                        children: [
+                          m.jsx('span', {
+                            className: 'test-file-test-status-icon',
+                            children: cc(d.outcome),
+                          }),
+                          m.jsxs('span', {
+                            children: [
+                              m.jsx(yn, {
+                                href: En({ test: d }, o),
+                                title: [...d.path, d.title].join(' › '),
+                                children: m.jsx('span', {
+                                  className: 'test-file-title',
+                                  children: [...d.path, d.title].join(' › '),
+                                }),
+                              }),
+                              m.jsx(Yh, {
+                                style: { marginLeft: '6px' },
+                                projectNames: i,
+                                activeProjectName: d.projectName,
+                                otherLabels: d.tags,
+                              }),
+                            ],
+                          }),
+                        ],
+                      }),
+                      m.jsx('span', {
+                        'data-testid': 'test-duration',
+                        style: { minWidth: '50px', textAlign: 'right' },
+                        children: yl(d.duration),
+                      }),
+                    ],
+                  }),
+                  m.jsx('div', {
+                    className: 'test-file-details-row',
+                    children: m.jsxs('div', {
+                      className: 'test-file-details-row-items',
+                      children: [
+                        m.jsx(yn, {
+                          href: En({ test: d }, o),
+                          title: [...d.path, d.title].join(' › '),
+                          className: 'test-file-path-link',
+                          children: m.jsxs('span', {
+                            className: 'test-file-path',
+                            children: [d.location.file, ':', d.location.line],
+                          }),
+                        }),
+                        m.jsx(bv, { test: d }),
+                        m.jsx(pv, { test: d }),
+                        m.jsx(Lh, { test: d, dim: !0 }),
+                      ],
+                    }),
+                  }),
+                ],
+              },
+              `test-${d.testId}`,
+            ),
+          ),
+        })
+      }
+      function bv({ test: u }) {
+        const i = ue()
+        for (const c of u.results)
+          for (const f of c.attachments)
+            if (
+              f.contentType.startsWith('image/') &&
+              f.name.match(/-(expected|actual|diff)/)
+            )
+              return m.jsx(gr, {
+                href: En(
+                  {
+                    test: u,
+                    result: c,
+                    anchor: `attachment-${c.attachments.indexOf(f)}`,
+                  },
+                  i,
+                ),
+                title: 'View images',
+                dim: !0,
+                children: w5(),
+              })
+      }
+      function pv({ test: u }) {
+        const i = ue(),
+          c = u.results.find((f) =>
+            f.attachments.some((r) => r.name === 'video'),
+          )
+        return c
+          ? m.jsx(gr, {
+              href: En({ test: u, result: c, anchor: 'attachment-video' }, i),
+              title: 'View video',
+              dim: !0,
+              children: R5(),
+            })
+          : void 0
+      }
+      class xv extends ct.Component {
+        constructor() {
+          super(...arguments)
+          dn(this, 'state', { error: null, errorInfo: null })
+        }
+        componentDidCatch(c, f) {
+          this.setState({ error: c, errorInfo: f })
+        }
+        render() {
+          var c, f, r
+          return this.state.error || this.state.errorInfo
+            ? m.jsxs('div', {
+                className: 'metadata-view p-3',
+                children: [
+                  m.jsx('p', {
+                    children:
+                      'An error was encountered when trying to render metadata.',
+                  }),
+                  m.jsx('p', {
+                    children: m.jsxs('pre', {
+                      style: { overflow: 'scroll' },
+                      children: [
+                        (c = this.state.error) == null ? void 0 : c.message,
+                        m.jsx('br', {}),
+                        (f = this.state.error) == null ? void 0 : f.stack,
+                        m.jsx('br', {}),
+                        (r = this.state.errorInfo) == null
+                          ? void 0
+                          : r.componentStack,
+                      ],
+                    }),
+                  }),
+                ],
+              })
+            : this.props.children
+        }
+      }
+      const Sv = (u) =>
+          m.jsx(xv, { children: m.jsx(Tv, { metadata: u.metadata }) }),
+        Tv = (u) => {
+          const i = ue(),
+            c = u.metadata,
+            f = i.has('show-metadata-other')
+              ? Object.entries(u.metadata).filter(([o]) => !qh.has(o))
+              : []
+          if (c.ci || c.gitCommit || f.length > 0)
+            return m.jsxs('div', {
+              className: 'metadata-view',
+              children: [
+                c.ci && !c.gitCommit && m.jsx(wv, { info: c.ci }),
+                c.gitCommit && m.jsx(Rv, { ci: c.ci, commit: c.gitCommit }),
+                f.length > 0 &&
+                  m.jsxs(m.Fragment, {
+                    children: [
+                      (c.gitCommit || c.ci) &&
+                        m.jsx('div', { className: 'metadata-separator' }),
+                      m.jsx('div', {
+                        className: 'metadata-section metadata-properties',
+                        role: 'list',
+                        children: f.map(([o, d]) => {
+                          const y =
+                              typeof d != 'object' || d === null || d === void 0
+                                ? String(d)
+                                : JSON.stringify(d),
+                            v = y.length > 1e3 ? y.slice(0, 1e3) + '…' : y
+                          return m.jsx(
+                            'div',
+                            {
+                              className: 'copyable-property',
+                              role: 'listitem',
+                              children: m.jsxs(hr, {
+                                value: y,
+                                children: [
+                                  m.jsx('span', {
+                                    style: { fontWeight: 'bold' },
+                                    title: o,
+                                    children: o,
+                                  }),
+                                  ': ',
+                                  m.jsx('span', { title: v, children: Ri(v) }),
+                                ],
+                              }),
+                            },
+                            o,
+                          )
+                        }),
+                      }),
+                    ],
+                  }),
+              ],
+            })
+        },
+        wv = ({ info: u }) => {
+          const i = u.prTitle || `Commit ${u.commitHash}`,
+            c = u.prHref || u.commitHref
+          return m.jsx('div', {
+            className: 'metadata-section',
+            role: 'list',
+            children: m.jsx('div', {
+              role: 'listitem',
+              children: m.jsx('a', {
+                href: Qe(c),
+                target: '_blank',
+                rel: 'noopener noreferrer',
+                title: i,
+                children: i,
+              }),
+            }),
+          })
+        },
+        Rv = ({ ci: u, commit: i }) => {
+          const c = (u == null ? void 0 : u.prTitle) || i.subject,
+            f =
+              (u == null ? void 0 : u.prHref) ||
+              (u == null ? void 0 : u.commitHref),
+            r = ` <${i.author.email}>`,
+            o = `${i.author.name}${r}`,
+            d = Intl.DateTimeFormat(void 0, { dateStyle: 'medium' }).format(
+              i.committer.time,
+            ),
+            y = Intl.DateTimeFormat(void 0, {
+              dateStyle: 'full',
+              timeStyle: 'long',
+            }).format(i.committer.time)
+          return m.jsxs('div', {
+            className: 'metadata-section',
+            role: 'list',
+            children: [
+              m.jsxs('div', {
+                role: 'listitem',
+                children: [
+                  f &&
+                    m.jsx('a', {
+                      href: Qe(f),
+                      target: '_blank',
+                      rel: 'noopener noreferrer',
+                      title: c,
+                      children: c,
+                    }),
+                  !f && m.jsx('span', { title: c, children: c }),
+                ],
+              }),
+              m.jsxs('div', {
+                role: 'listitem',
+                className: 'hbox',
+                children: [
+                  m.jsx('span', { className: 'mr-1', children: o }),
+                  m.jsxs('span', { title: y, children: [' on ', d] }),
+                ],
+              }),
+            ],
+          })
+        },
+        qh = new Set(['ci', 'gitCommit', 'gitDiff', 'actualWorkers']),
+        Ov = (u) => {
+          const i = Object.entries(u).filter(([c]) => !qh.has(c))
+          return !u.ci && !u.gitCommit && !i.length
+        },
+        Dv = ({
+          files: u,
+          expandedFiles: i,
+          setExpandedFiles: c,
+          projectNames: f,
+        }) => {
+          const r = ct.useMemo(() => {
+            const o = []
+            let d = 0
+            for (const y of u)
+              ((d += y.tests.length),
+                o.push({ file: y, defaultExpanded: d < 200 }))
+            return o
+          }, [u])
+          return m.jsx(m.Fragment, {
+            children:
+              r.length > 0
+                ? r.map(({ file: o, defaultExpanded: d }) =>
+                    m.jsx(
+                      Zh,
+                      {
+                        file: o,
+                        projectNames: f,
+                        isFileExpanded: (y) => {
+                          const v = i.get(y)
+                          return v === void 0 ? d : !!v
+                        },
+                        setFileExpanded: (y, v) => {
+                          const A = new Map(i)
+                          ;(A.set(y, v), c(A))
+                        },
+                      },
+                      `file-${o.fileId}`,
+                    ),
+                  )
+                : m.jsx('div', {
+                    className: 'chip-header test-file-no-files',
+                    children: 'No tests found',
+                  }),
+          })
+        },
+        x2 = ({
+          report: u,
+          filteredStats: i,
+          metadataVisible: c,
+          toggleMetadataVisible: f,
+        }) => {
+          if (!u) return null
+          const r = u.projectNames.length === 1 && !!u.projectNames[0],
+            o = !r && !i,
+            d =
+              !Ov(u.metadata) &&
+              m.jsxs('div', {
+                className: Ye(
+                  'metadata-toggle',
+                  !o && 'metadata-toggle-second-line',
+                ),
+                role: 'button',
+                onClick: f,
+                title: c ? 'Hide metadata' : 'Show metadata',
+                children: [c ? Mi() : vl(), 'Metadata'],
+              }),
+            y = m.jsxs('div', {
+              className: 'test-file-header-info',
+              children: [
+                r &&
+                  m.jsxs('div', {
+                    'data-testid': 'project-name',
+                    children: ['Project: ', u.projectNames[0]],
+                  }),
+                i &&
+                  m.jsxs('div', {
+                    'data-testid': 'filtered-tests-count',
+                    children: [
+                      'Filtered: ',
+                      i.total,
+                      ' ',
+                      !!i.total && '(' + yl(i.duration) + ')',
+                    ],
+                  }),
+                o && d,
+              ],
+            }),
+            v = m.jsxs(m.Fragment, {
+              children: [
+                m.jsx('div', {
+                  'data-testid': 'overall-time',
+                  style: { marginRight: '10px' },
+                  children: u ? new Date(u.startTime).toLocaleString() : '',
+                }),
+                m.jsxs('div', {
+                  'data-testid': 'overall-duration',
+                  children: ['Total time: ', yl(u.duration ?? 0)],
+                }),
+              ],
+            })
+          return m.jsxs(m.Fragment, {
+            children: [
+              m.jsx(Ar, {
+                title: u.options.title,
+                leftSuperHeader: y,
+                rightSuperHeader: v,
+              }),
+              !o && d,
+              c && m.jsx(Sv, { metadata: u.metadata }),
+              !!u.errors.length &&
+                m.jsx(Ke, {
+                  header: 'Errors',
+                  dataTestId: 'report-errors',
+                  children: u.errors.map((A, E) =>
+                    m.jsx(vr, { code: A }, 'test-report-error-message-' + E),
+                  ),
+                }),
+            ],
+          })
+        }
+      function Cv({ report: u, tests: i }) {
+        return m.jsx(m.Fragment, {
+          children: m.jsx(Mv, { report: u, tests: i }),
+        })
+      }
+      function Mv({ report: u, tests: i }) {
+        const [c, f] = ie.useState(50)
+        return m.jsx(Zh, {
+          file: {
+            fileId: 'slowest',
+            fileName: 'Slowest Tests',
+            tests: i.slice(0, c),
+            stats: null,
+          },
+          projectNames: u.json().projectNames,
+          footer:
+            c < i.length
+              ? m.jsxs('button', {
+                  className: 'link-badge fullwidth-link',
+                  style: { padding: '8px 5px' },
+                  onClick: () => f((r) => r + 50),
+                  children: [Mi(), 'Show 50 more'],
+                })
+              : void 0,
+        })
+      }
+      const jv = (u) => !u.has('testId') && !u.has('speedboard'),
+        Hv = (u) => u.has('testId'),
+        Nv = (u) => u.has('speedboard') && !u.has('testId'),
+        Bv = ({ report: u }) => {
+          var I, V
+          const i = ue(),
+            [c, f] = ct.useState(new Map()),
+            [r, o] = ct.useState(i.get('q') || ''),
+            [d, y] = ct.useState(!1),
+            v = i.has('speedboard'),
+            [A] = Uh('mergeFiles', !1),
+            E = i.get('testId'),
+            w = ((I = i.get('q')) == null ? void 0 : I.toString()) || '',
+            R = w ? '&q=' + w : '',
+            z =
+              (V = u == null ? void 0 : u.json()) == null
+                ? void 0
+                : V.options.title,
+            N = ct.useMemo(() => {
+              const j = new Map()
+              for (const G of (u == null ? void 0 : u.json().files) || [])
+                for (const L of G.tests) j.set(L.testId, G.fileId)
+              return j
+            }, [u]),
+            x = ct.useMemo(() => lc.parse(r), [r]),
+            p = ct.useMemo(
+              () =>
+                x.empty()
+                  ? void 0
+                  : Qv((u == null ? void 0 : u.json().files) || [], x),
+              [u, x],
+            ),
+            T = ct.useMemo(
+              () => (v ? zv(u, x) : A ? Lv(u, x) : Yv(u, x)),
+              [u, x, A, v],
+            ),
+            { prev: D, next: U } = ct.useMemo(() => {
+              const j = T.tests.findIndex((W) => W.testId === E),
+                G = j > 0 ? T.tests[j - 1] : void 0,
+                L = j < T.tests.length - 1 ? T.tests[j + 1] : void 0
+              return { prev: G, next: L }
+            }, [E, T])
+          return (
+            ct.useEffect(() => {
+              const j = (G) => {
+                if (
+                  !(
+                    G.target instanceof HTMLInputElement ||
+                    G.target instanceof HTMLTextAreaElement ||
+                    G.shiftKey ||
+                    G.ctrlKey ||
+                    G.metaKey ||
+                    G.altKey
+                  )
+                )
+                  switch (G.key) {
+                    case 'a':
+                      ;(G.preventDefault(), _n('#?'))
+                      break
+                    case 'p':
+                      ;(G.preventDefault(),
+                        i.delete('testId'),
+                        i.delete('speedboard'),
+                        _n(wa(i, 's:passed', !1)))
+                      break
+                    case 'f':
+                      ;(G.preventDefault(),
+                        i.delete('testId'),
+                        i.delete('speedboard'),
+                        _n(wa(i, 's:failed', !1)))
+                      break
+                    case 'ArrowLeft':
+                      D &&
+                        (G.preventDefault(),
+                        i.delete('testId'),
+                        _n(En({ test: D }, i) + R))
+                      break
+                    case 'ArrowRight':
+                      U &&
+                        (G.preventDefault(),
+                        i.delete('testId'),
+                        _n(En({ test: U }, i) + R))
+                      break
+                  }
+              }
+              return (
+                document.addEventListener('keydown', j),
+                () => document.removeEventListener('keydown', j)
+              )
+            }, [D, U, R, w, i]),
+            ct.useEffect(() => {
+              z
+                ? (document.title = z)
+                : (document.title = 'Playwright Test Report')
+            }, [z]),
+            m.jsx('div', {
+              className: 'htmlreport vbox px-4 pb-4',
+              children: m.jsxs('main', {
+                children: [
+                  u &&
+                    m.jsx(F5, {
+                      stats: u.json().stats,
+                      filterText: r,
+                      setFilterText: o,
+                    }),
+                  m.jsxs(Yf, {
+                    predicate: jv,
+                    children: [
+                      m.jsx(x2, {
+                        report: u == null ? void 0 : u.json(),
+                        filteredStats: p,
+                        metadataVisible: d,
+                        toggleMetadataVisible: () => y((j) => !j),
+                      }),
+                      m.jsx(Dv, {
+                        files: T.files,
+                        expandedFiles: c,
+                        setExpandedFiles: f,
+                        projectNames:
+                          (u == null ? void 0 : u.json().projectNames) || [],
+                      }),
+                    ],
+                  }),
+                  m.jsxs(Yf, {
+                    predicate: Nv,
+                    children: [
+                      m.jsx(x2, {
+                        report: u == null ? void 0 : u.json(),
+                        filteredStats: p,
+                        metadataVisible: d,
+                        toggleMetadataVisible: () => y((j) => !j),
+                      }),
+                      u && m.jsx(Cv, { report: u, tests: T.tests }),
+                    ],
+                  }),
+                  m.jsx(Yf, {
+                    predicate: Hv,
+                    children:
+                      u &&
+                      m.jsx(Uv, {
+                        report: u,
+                        next: U,
+                        prev: D,
+                        testId: E,
+                        testIdToFileIdMap: N,
+                      }),
+                  }),
+                ],
+              }),
+            })
+          )
+        },
+        Uv = ({
+          report: u,
+          testIdToFileIdMap: i,
+          next: c,
+          prev: f,
+          testId: r,
+        }) => {
+          const o = ue(),
+            [d, y] = ct.useState('loading'),
+            v = +(o.get('run') || '0')
+          if (
+            (ct.useEffect(() => {
+              ;(async () => {
+                if (!r || (typeof d == 'object' && r === d.testId)) return
+                const R = i.get(r)
+                if (!R) {
+                  y('not-found')
+                  return
+                }
+                const z = await u.entry(`${R}.json`)
+                y(
+                  (z == null ? void 0 : z.tests.find((N) => N.testId === r)) ||
+                    'not-found',
+                )
+              })()
+            }, [d, u, r, i]),
+            d === 'loading')
+          )
+            return m.jsx('div', { className: 'test-case-column' })
+          if (d === 'not-found')
+            return m.jsxs('div', {
+              className: 'test-case-column',
+              children: [
+                m.jsx(Ar, { title: 'Test not found' }),
+                m.jsxs('div', {
+                  className: 'test-case-location',
+                  children: ['Test ID: ', r],
+                }),
+              ],
+            })
+          const { projectNames: A, metadata: E, options: w } = u.json()
+          return m.jsx('div', {
+            className: 'test-case-column',
+            children: m.jsx(yv, {
+              projectNames: A,
+              testRunMetadata: E,
+              options: w,
+              next: c,
+              prev: f,
+              test: d,
+              run: v,
+            }),
+          })
+        }
+      function Qv(u, i) {
+        const c = { total: 0, duration: 0 }
+        for (const f of u) {
+          const r = f.tests.filter((o) => i.matches(o))
+          c.total += r.length
+          for (const o of r) c.duration += o.duration
+        }
+        return c
+      }
+      function Yv(u, i) {
+        const c = { files: [], tests: [] }
+        for (const f of (u == null ? void 0 : u.json().files) || []) {
+          const r = f.tests.filter((o) => i.matches(o))
+          ;(r.length && c.files.push({ ...f, tests: r }), c.tests.push(...r))
+        }
+        return c
+      }
+      function Lv(u, i) {
+        const c = [],
+          f = new Map()
+        for (const o of (u == null ? void 0 : u.json().files) || []) {
+          const d = o.tests.filter((y) => i.matches(y))
+          for (const y of d) {
+            const v = y.path[0] ?? '<anonymous>'
+            let A = f.get(v)
+            A ||
+              ((A = {
+                fileId: v,
+                fileName: v,
+                tests: [],
+                stats: {
+                  total: 0,
+                  expected: 0,
+                  unexpected: 0,
+                  flaky: 0,
+                  skipped: 0,
+                  ok: !0,
+                },
+              }),
+              f.set(v, A),
+              c.push(A))
+            const E = { ...y, path: y.path.slice(1) }
+            A.tests.push(E)
+          }
+        }
+        c.sort((o, d) => o.fileName.localeCompare(d.fileName))
+        const r = { files: c, tests: [] }
+        for (const o of c) r.tests.push(...o.tests)
+        return r
+      }
+      function zv(u, i) {
+        const f = ((u == null ? void 0 : u.json().files) || [])
+          .flatMap((r) => r.tests)
+          .filter((r) => i.matches(r))
+        return (
+          f.sort((r, o) => o.duration - r.duration),
+          { files: [], tests: f }
+        )
+      }
+      const Gv =
+          "data:image/svg+xml,%3csvg%20width='400'%20height='400'%20viewBox='0%200%20400%20400'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M136.444%20221.556C123.558%20225.213%20115.104%20231.625%20109.535%20238.032C114.869%20233.364%20122.014%20229.08%20131.652%20226.348C141.51%20223.554%20149.92%20223.574%20156.869%20224.915V219.481C150.941%20218.939%20144.145%20219.371%20136.444%20221.556ZM108.946%20175.876L61.0895%20188.484C61.0895%20188.484%2061.9617%20189.716%2063.5767%20191.36L104.153%20180.668C104.153%20180.668%20103.578%20188.077%2098.5847%20194.705C108.03%20187.559%20108.946%20175.876%20108.946%20175.876ZM149.005%20288.347C81.6582%20306.486%2046.0272%20228.438%2035.2396%20187.928C30.2556%20169.229%2028.0799%20155.067%2027.5%20145.928C27.4377%20144.979%2027.4665%20144.179%2027.5336%20143.446C24.04%20143.657%2022.3674%20145.473%2022.7077%20150.721C23.2876%20159.855%2025.4633%20174.016%2030.4473%20192.721C41.2301%20233.225%2076.8659%20311.273%20144.213%20293.134C158.872%20289.185%20169.885%20281.992%20178.152%20272.81C170.532%20279.692%20160.995%20285.112%20149.005%20288.347ZM161.661%20128.11V132.903H188.077C187.535%20131.206%20186.989%20129.677%20186.447%20128.11H161.661Z'%20fill='%232D4552'/%3e%3cpath%20d='M193.981%20167.584C205.861%20170.958%20212.144%20179.287%20215.465%20186.658L228.711%20190.42C228.711%20190.42%20226.904%20164.623%20203.57%20157.995C181.741%20151.793%20168.308%20170.124%20166.674%20172.496C173.024%20167.972%20182.297%20164.268%20193.981%20167.584ZM299.422%20186.777C277.573%20180.547%20264.145%20198.916%20262.535%20201.255C268.89%20196.736%20278.158%20193.031%20289.837%20196.362C301.698%20199.741%20307.976%20208.06%20311.307%20215.436L324.572%20219.212C324.572%20219.212%20322.736%20193.41%20299.422%20186.777ZM286.262%20254.795L176.072%20223.99C176.072%20223.99%20177.265%20230.038%20181.842%20237.869L274.617%20263.805C282.255%20259.386%20286.262%20254.795%20286.262%20254.795ZM209.867%20321.102C122.618%20297.71%20133.166%20186.543%20147.284%20133.865C153.097%20112.156%20159.073%2096.0203%20164.029%2085.204C161.072%2084.5953%20158.623%2086.1529%20156.203%2091.0746C150.941%20101.747%20144.212%20119.124%20137.7%20143.45C123.586%20196.127%20113.038%20307.29%20200.283%20330.682C241.406%20341.699%20273.442%20324.955%20297.323%20298.659C274.655%20319.19%20245.714%20330.701%20209.867%20321.102Z'%20fill='%232D4552'/%3e%3cpath%20d='M161.661%20262.296V239.863L99.3324%20257.537C99.3324%20257.537%20103.938%20230.777%20136.444%20221.556C146.302%20218.762%20154.713%20218.781%20161.661%20220.123V128.11H192.869C189.471%20117.61%20186.184%20109.526%20183.423%20103.909C178.856%2094.612%20174.174%20100.775%20163.545%20109.665C156.059%20115.919%20137.139%20129.261%20108.668%20136.933C80.1966%20144.61%2057.179%20142.574%2047.5752%20140.911C33.9601%20138.562%2026.8387%20135.572%2027.5049%20145.928C28.0847%20155.062%2030.2605%20169.224%2035.2445%20187.928C46.0272%20228.433%2081.663%20306.481%20149.01%20288.342C166.602%20283.602%20179.019%20274.233%20187.626%20262.291H161.661V262.296ZM61.0848%20188.484L108.946%20175.876C108.946%20175.876%20107.551%20194.288%2089.6087%20199.018C71.6614%20203.743%2061.0848%20188.484%2061.0848%20188.484Z'%20fill='%23E2574C'/%3e%3cpath%20d='M341.786%20129.174C329.345%20131.355%20299.498%20134.072%20262.612%20124.185C225.716%20114.304%20201.236%2097.0224%20191.537%2088.8994C177.788%2077.3834%20171.74%2069.3802%20165.788%2081.4857C160.526%2092.163%20153.797%20109.54%20147.284%20133.866C133.171%20186.543%20122.623%20297.706%20209.867%20321.098C297.093%20344.47%20343.53%20242.92%20357.644%20190.238C364.157%20165.917%20367.013%20147.5%20367.799%20135.625C368.695%20122.173%20359.455%20126.078%20341.786%20129.174ZM166.497%20172.756C166.497%20172.756%20180.246%20151.372%20203.565%20158C226.899%20164.628%20228.706%20190.425%20228.706%20190.425L166.497%20172.756ZM223.42%20268.713C182.403%20256.698%20176.077%20223.99%20176.077%20223.99L286.262%20254.796C286.262%20254.791%20264.021%20280.578%20223.42%20268.713ZM262.377%20201.495C262.377%20201.495%20276.107%20180.126%20299.422%20186.773C322.736%20193.411%20324.572%20219.208%20324.572%20219.208L262.377%20201.495Z'%20fill='%232EAD33'/%3e%3cpath%20d='M139.88%20246.04L99.3324%20257.532C99.3324%20257.532%20103.737%20232.44%20133.607%20222.496L110.647%20136.33L108.663%20136.933C80.1918%20144.611%2057.1742%20142.574%2047.5704%20140.911C33.9554%20138.563%2026.834%20135.572%2027.5001%20145.929C28.08%20155.063%2030.2557%20169.224%2035.2397%20187.929C46.0225%20228.433%2081.6583%20306.481%20149.005%20288.342L150.989%20287.719L139.88%20246.04ZM61.0848%20188.485L108.946%20175.876C108.946%20175.876%20107.551%20194.288%2089.6087%20199.018C71.6615%20203.743%2061.0848%20188.485%2061.0848%20188.485Z'%20fill='%23D65348'/%3e%3cpath%20d='M225.27%20269.163L223.415%20268.712C182.398%20256.698%20176.072%20223.99%20176.072%20223.99L232.89%20239.872L262.971%20124.281L262.607%20124.185C225.711%20114.304%20201.232%2097.0224%20191.532%2088.8994C177.783%2077.3834%20171.735%2069.3802%20165.783%2081.4857C160.526%2092.163%20153.797%20109.54%20147.284%20133.866C133.171%20186.543%20122.623%20297.706%20209.867%20321.097L211.655%20321.5L225.27%20269.163ZM166.497%20172.756C166.497%20172.756%20180.246%20151.372%20203.565%20158C226.899%20164.628%20228.706%20190.425%20228.706%20190.425L166.497%20172.756Z'%20fill='%231D8D22'/%3e%3cpath%20d='M141.946%20245.451L131.072%20248.537C133.641%20263.019%20138.169%20276.917%20145.276%20289.195C146.513%20288.922%20147.74%20288.687%20149%20288.342C152.302%20287.451%20155.364%20286.348%20158.312%20285.145C150.371%20273.361%20145.118%20259.789%20141.946%20245.451ZM137.7%20143.451C132.112%20164.307%20127.113%20194.326%20128.489%20224.436C130.952%20223.367%20133.554%20222.371%20136.444%20221.551L138.457%20221.101C136.003%20188.939%20141.308%20156.165%20147.284%20133.866C148.799%20128.225%20150.318%20122.978%20151.832%20118.085C149.393%20119.637%20146.767%20121.228%20143.776%20122.867C141.759%20129.093%20139.722%20135.898%20137.7%20143.451Z'%20fill='%23C04B41'/%3e%3c/svg%3e",
+        Gf = o5,
+        yr = document.createElement('link')
+      yr.rel = 'shortcut icon'
+      yr.href = Gv
+      document.head.appendChild(yr)
+      const Xv = () => {
+        const [u, i] = ct.useState()
+        return (
+          ct.useEffect(() => {
+            const c = new Vv()
+            c.load().then(() => {
+              var f
+              ;((f = document.getElementById('playwrightReportBase64')) ==
+                null || f.remove(),
+                i(c))
+            })
+          }, []),
+          m.jsx(z5, { children: m.jsx(Bv, { report: u }) })
+        )
+      }
+      window.onload = () => {
+        ;(q5(),
+          E5.createRoot(document.querySelector('#root')).render(m.jsx(Xv, {})))
+      }
+      class Vv {
+        constructor() {
+          dn(this, '_entries', new Map())
+          dn(this, '_json')
+        }
+        async load() {
+          const i = document.getElementById(
+              'playwrightReportBase64',
+            ).textContent,
+            c = new Gf.ZipReader(new Gf.Data64URIReader(i), {
+              useWebWorkers: !1,
+            })
+          for (const f of await c.getEntries()) this._entries.set(f.filename, f)
+          this._json = await this.entry('report.json')
+        }
+        json() {
+          return this._json
+        }
+        async entry(i) {
+          const c = this._entries.get(i),
+            f = new Gf.TextWriter()
+          return (await c.getData(f), JSON.parse(await f.getData()))
+        }
+      }
+    </script>
+    <style type="text/css">
+      :root {
+        --color-canvas-default-transparent: rgba(255, 255, 255, 0);
+        --color-marketing-icon-primary: #218bff;
+        --color-marketing-icon-secondary: #54aeff;
+        --color-diff-blob-addition-num-text: #24292f;
+        --color-diff-blob-addition-fg: #24292f;
+        --color-diff-blob-addition-num-bg: #ccffd8;
+        --color-diff-blob-addition-line-bg: #e6ffec;
+        --color-diff-blob-addition-word-bg: #abf2bc;
+        --color-diff-blob-deletion-num-text: #24292f;
+        --color-diff-blob-deletion-fg: #24292f;
+        --color-diff-blob-deletion-num-bg: #ffd7d5;
+        --color-diff-blob-deletion-line-bg: #ffebe9;
+        --color-diff-blob-deletion-word-bg: rgba(255, 129, 130, 0.4);
+        --color-diff-blob-hunk-num-bg: rgba(84, 174, 255, 0.4);
+        --color-diff-blob-expander-icon: #57606a;
+        --color-diff-blob-selected-line-highlight-mix-blend-mode: multiply;
+        --color-diffstat-deletion-border: rgba(27, 31, 36, 0.15);
+        --color-diffstat-addition-border: rgba(27, 31, 36, 0.15);
+        --color-diffstat-addition-bg: #2da44e;
+        --color-search-keyword-hl: #fff8c5;
+        --color-prettylights-syntax-comment: #6e7781;
+        --color-prettylights-syntax-constant: #0550ae;
+        --color-prettylights-syntax-entity: #8250df;
+        --color-prettylights-syntax-storage-modifier-import: #24292f;
+        --color-prettylights-syntax-entity-tag: #116329;
+        --color-prettylights-syntax-keyword: #cf222e;
+        --color-prettylights-syntax-string: #0a3069;
+        --color-prettylights-syntax-variable: #953800;
+        --color-prettylights-syntax-brackethighlighter-unmatched: #82071e;
+        --color-prettylights-syntax-invalid-illegal-text: #f6f8fa;
+        --color-prettylights-syntax-invalid-illegal-bg: #82071e;
+        --color-prettylights-syntax-carriage-return-text: #f6f8fa;
+        --color-prettylights-syntax-carriage-return-bg: #cf222e;
+        --color-prettylights-syntax-string-regexp: #116329;
+        --color-prettylights-syntax-markup-list: #3b2300;
+        --color-prettylights-syntax-markup-heading: #0550ae;
+        --color-prettylights-syntax-markup-italic: #24292f;
+        --color-prettylights-syntax-markup-bold: #24292f;
+        --color-prettylights-syntax-markup-deleted-text: #82071e;
+        --color-prettylights-syntax-markup-deleted-bg: #ffebe9;
+        --color-prettylights-syntax-markup-inserted-text: #116329;
+        --color-prettylights-syntax-markup-inserted-bg: #dafbe1;
+        --color-prettylights-syntax-markup-changed-text: #953800;
+        --color-prettylights-syntax-markup-changed-bg: #ffd8b5;
+        --color-prettylights-syntax-markup-ignored-text: #eaeef2;
+        --color-prettylights-syntax-markup-ignored-bg: #0550ae;
+        --color-prettylights-syntax-meta-diff-range: #8250df;
+        --color-prettylights-syntax-brackethighlighter-angle: #57606a;
+        --color-prettylights-syntax-sublimelinter-gutter-mark: #8c959f;
+        --color-prettylights-syntax-constant-other-reference-link: #0a3069;
+        --color-codemirror-text: #24292f;
+        --color-codemirror-bg: #ffffff;
+        --color-codemirror-gutters-bg: #ffffff;
+        --color-codemirror-guttermarker-text: #ffffff;
+        --color-codemirror-guttermarker-subtle-text: #6e7781;
+        --color-codemirror-linenumber-text: #57606a;
+        --color-codemirror-cursor: #24292f;
+        --color-codemirror-selection-bg: rgba(84, 174, 255, 0.4);
+        --color-codemirror-activeline-bg: rgba(234, 238, 242, 0.5);
+        --color-codemirror-matchingbracket-text: #24292f;
+        --color-codemirror-lines-bg: #ffffff;
+        --color-codemirror-syntax-comment: #24292f;
+        --color-codemirror-syntax-constant: #0550ae;
+        --color-codemirror-syntax-entity: #8250df;
+        --color-codemirror-syntax-keyword: #cf222e;
+        --color-codemirror-syntax-storage: #cf222e;
+        --color-codemirror-syntax-string: #0a3069;
+        --color-codemirror-syntax-support: #0550ae;
+        --color-codemirror-syntax-variable: #953800;
+        --color-checks-bg: #24292f;
+        --color-checks-run-border-width: 0px;
+        --color-checks-container-border-width: 0px;
+        --color-checks-text-primary: #f6f8fa;
+        --color-checks-text-secondary: #8c959f;
+        --color-checks-text-link: #54aeff;
+        --color-checks-btn-icon: #afb8c1;
+        --color-checks-btn-hover-icon: #f6f8fa;
+        --color-checks-btn-hover-bg: rgba(255, 255, 255, 0.125);
+        --color-checks-input-text: #eaeef2;
+        --color-checks-input-placeholder-text: #8c959f;
+        --color-checks-input-focus-text: #8c959f;
+        --color-checks-input-bg: #32383f;
+        --color-checks-input-shadow: none;
+        --color-checks-donut-error: #fa4549;
+        --color-checks-donut-pending: #bf8700;
+        --color-checks-donut-success: #2da44e;
+        --color-checks-donut-neutral: #afb8c1;
+        --color-checks-dropdown-text: #afb8c1;
+        --color-checks-dropdown-bg: #32383f;
+        --color-checks-dropdown-border: #424a53;
+        --color-checks-dropdown-shadow: rgba(27, 31, 36, 0.3);
+        --color-checks-dropdown-hover-text: #f6f8fa;
+        --color-checks-dropdown-hover-bg: #424a53;
+        --color-checks-dropdown-btn-hover-text: #f6f8fa;
+        --color-checks-dropdown-btn-hover-bg: #32383f;
+        --color-checks-scrollbar-thumb-bg: #57606a;
+        --color-checks-header-label-text: #d0d7de;
+        --color-checks-header-label-open-text: #f6f8fa;
+        --color-checks-header-border: #32383f;
+        --color-checks-header-icon: #8c959f;
+        --color-checks-line-text: #d0d7de;
+        --color-checks-line-num-text: rgba(140, 149, 159, 0.75);
+        --color-checks-line-timestamp-text: #8c959f;
+        --color-checks-line-hover-bg: #32383f;
+        --color-checks-line-selected-bg: rgba(33, 139, 255, 0.15);
+        --color-checks-line-selected-num-text: #54aeff;
+        --color-checks-line-dt-fm-text: #24292f;
+        --color-checks-line-dt-fm-bg: #9a6700;
+        --color-checks-gate-bg: rgba(125, 78, 0, 0.15);
+        --color-checks-gate-text: #d0d7de;
+        --color-checks-gate-waiting-text: #afb8c1;
+        --color-checks-step-header-open-bg: #32383f;
+        --color-checks-step-error-text: #ff8182;
+        --color-checks-step-warning-text: #d4a72c;
+        --color-checks-logline-text: #8c959f;
+        --color-checks-logline-num-text: rgba(140, 149, 159, 0.75);
+        --color-checks-logline-debug-text: #c297ff;
+        --color-checks-logline-error-text: #d0d7de;
+        --color-checks-logline-error-num-text: #ff8182;
+        --color-checks-logline-error-bg: rgba(164, 14, 38, 0.15);
+        --color-checks-logline-warning-text: #d0d7de;
+        --color-checks-logline-warning-num-text: #d4a72c;
+        --color-checks-logline-warning-bg: rgba(125, 78, 0, 0.15);
+        --color-checks-logline-command-text: #54aeff;
+        --color-checks-logline-section-text: #4ac26b;
+        --color-checks-ansi-black: #24292f;
+        --color-checks-ansi-black-bright: #32383f;
+        --color-checks-ansi-white: #d0d7de;
+        --color-checks-ansi-white-bright: #d0d7de;
+        --color-checks-ansi-gray: #8c959f;
+        --color-checks-ansi-red: #ff8182;
+        --color-checks-ansi-red-bright: #ffaba8;
+        --color-checks-ansi-green: #4ac26b;
+        --color-checks-ansi-green-bright: #6fdd8b;
+        --color-checks-ansi-yellow: #d4a72c;
+        --color-checks-ansi-yellow-bright: #eac54f;
+        --color-checks-ansi-blue: #54aeff;
+        --color-checks-ansi-blue-bright: #80ccff;
+        --color-checks-ansi-magenta: #c297ff;
+        --color-checks-ansi-magenta-bright: #d8b9ff;
+        --color-checks-ansi-cyan: #76e3ea;
+        --color-checks-ansi-cyan-bright: #b3f0ff;
+        --color-project-header-bg: #24292f;
+        --color-project-sidebar-bg: #ffffff;
+        --color-project-gradient-in: #ffffff;
+        --color-project-gradient-out: rgba(255, 255, 255, 0);
+        --color-mktg-success: rgba(36, 146, 67, 1);
+        --color-mktg-info: rgba(19, 119, 234, 1);
+        --color-mktg-bg-shade-gradient-top: rgba(27, 31, 36, 0.065);
+        --color-mktg-bg-shade-gradient-bottom: rgba(27, 31, 36, 0);
+        --color-mktg-btn-bg-top: hsla(228, 82%, 66%, 1);
+        --color-mktg-btn-bg-bottom: #4969ed;
+        --color-mktg-btn-bg-overlay-top: hsla(228, 74%, 59%, 1);
+        --color-mktg-btn-bg-overlay-bottom: #3355e0;
+        --color-mktg-btn-text: #ffffff;
+        --color-mktg-btn-primary-bg-top: hsla(137, 56%, 46%, 1);
+        --color-mktg-btn-primary-bg-bottom: #2ea44f;
+        --color-mktg-btn-primary-bg-overlay-top: hsla(134, 60%, 38%, 1);
+        --color-mktg-btn-primary-bg-overlay-bottom: #22863a;
+        --color-mktg-btn-primary-text: #ffffff;
+        --color-mktg-btn-enterprise-bg-top: hsla(249, 100%, 72%, 1);
+        --color-mktg-btn-enterprise-bg-bottom: #6f57ff;
+        --color-mktg-btn-enterprise-bg-overlay-top: hsla(248, 65%, 63%, 1);
+        --color-mktg-btn-enterprise-bg-overlay-bottom: #614eda;
+        --color-mktg-btn-enterprise-text: #ffffff;
+        --color-mktg-btn-outline-text: #4969ed;
+        --color-mktg-btn-outline-border: rgba(73, 105, 237, 0.3);
+        --color-mktg-btn-outline-hover-text: #3355e0;
+        --color-mktg-btn-outline-hover-border: rgba(51, 85, 224, 0.5);
+        --color-mktg-btn-outline-focus-border: #4969ed;
+        --color-mktg-btn-outline-focus-border-inset: rgba(73, 105, 237, 0.5);
+        --color-mktg-btn-dark-text: #ffffff;
+        --color-mktg-btn-dark-border: rgba(255, 255, 255, 0.3);
+        --color-mktg-btn-dark-hover-text: #ffffff;
+        --color-mktg-btn-dark-hover-border: rgba(255, 255, 255, 0.5);
+        --color-mktg-btn-dark-focus-border: #ffffff;
+        --color-mktg-btn-dark-focus-border-inset: rgba(255, 255, 255, 0.5);
+        --color-avatar-bg: #ffffff;
+        --color-avatar-border: rgba(27, 31, 36, 0.15);
+        --color-avatar-stack-fade: #afb8c1;
+        --color-avatar-stack-fade-more: #d0d7de;
+        --color-avatar-child-shadow: -2px -2px 0 rgba(255, 255, 255, 0.8);
+        --color-topic-tag-border: rgba(0, 0, 0, 0);
+        --color-select-menu-backdrop-border: rgba(0, 0, 0, 0);
+        --color-select-menu-tap-highlight: rgba(175, 184, 193, 0.5);
+        --color-select-menu-tap-focus-bg: #b6e3ff;
+        --color-overlay-shadow:
+          0 1px 3px rgba(27, 31, 36, 0.12), 0 8px 24px rgba(66, 74, 83, 0.12);
+        --color-header-text: rgba(255, 255, 255, 0.7);
+        --color-header-bg: #24292f;
+        --color-header-logo: #ffffff;
+        --color-header-search-bg: #24292f;
+        --color-header-search-border: #57606a;
+        --color-sidenav-selected-bg: #ffffff;
+        --color-menu-bg-active: rgba(0, 0, 0, 0);
+        --color-control-transparent-bg-hover: #818b981a;
+        --color-input-disabled-bg: rgba(175, 184, 193, 0.2);
+        --color-timeline-badge-bg: #eaeef2;
+        --color-ansi-black: #24292f;
+        --color-ansi-black-bright: #57606a;
+        --color-ansi-white: #6e7781;
+        --color-ansi-white-bright: #8c959f;
+        --color-ansi-gray: #6e7781;
+        --color-ansi-red: #cf222e;
+        --color-ansi-red-bright: #a40e26;
+        --color-ansi-green: #116329;
+        --color-ansi-green-bright: #1a7f37;
+        --color-ansi-yellow: #4d2d00;
+        --color-ansi-yellow-bright: #633c01;
+        --color-ansi-blue: #0969da;
+        --color-ansi-blue-bright: #218bff;
+        --color-ansi-magenta: #8250df;
+        --color-ansi-magenta-bright: #a475f9;
+        --color-ansi-cyan: #1b7c83;
+        --color-ansi-cyan-bright: #3192aa;
+        --color-btn-text: #24292f;
+        --color-btn-bg: #f6f8fa;
+        --color-btn-border: rgba(27, 31, 36, 0.15);
+        --color-btn-shadow: 0 1px 0 rgba(27, 31, 36, 0.04);
+        --color-btn-inset-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.25);
+        --color-btn-hover-bg: #f3f4f6;
+        --color-btn-hover-border: rgba(27, 31, 36, 0.15);
+        --color-btn-active-bg: hsla(220, 14%, 93%, 1);
+        --color-btn-active-border: rgba(27, 31, 36, 0.15);
+        --color-btn-selected-bg: hsla(220, 14%, 94%, 1);
+        --color-btn-focus-bg: #f6f8fa;
+        --color-btn-focus-border: rgba(27, 31, 36, 0.15);
+        --color-btn-focus-shadow: 0 0 0 3px rgba(9, 105, 218, 0.3);
+        --color-btn-shadow-active: inset 0 0.15em 0.3em rgba(27, 31, 36, 0.15);
+        --color-btn-shadow-input-focus: 0 0 0 0.2em rgba(9, 105, 218, 0.3);
+        --color-btn-counter-bg: rgba(27, 31, 36, 0.08);
+        --color-btn-primary-text: #ffffff;
+        --color-btn-primary-bg: #2da44e;
+        --color-btn-primary-border: rgba(27, 31, 36, 0.15);
+        --color-btn-primary-shadow: 0 1px 0 rgba(27, 31, 36, 0.1);
+        --color-btn-primary-inset-shadow: inset 0 1px 0
+          rgba(255, 255, 255, 0.03);
+        --color-btn-primary-hover-bg: #2c974b;
+        --color-btn-primary-hover-border: rgba(27, 31, 36, 0.15);
+        --color-btn-primary-selected-bg: hsla(137, 55%, 36%, 1);
+        --color-btn-primary-selected-shadow: inset 0 1px 0 rgba(0, 45, 17, 0.2);
+        --color-btn-primary-disabled-text: rgba(255, 255, 255, 0.8);
+        --color-btn-primary-disabled-bg: #94d3a2;
+        --color-btn-primary-disabled-border: rgba(27, 31, 36, 0.15);
+        --color-btn-primary-focus-bg: #2da44e;
+        --color-btn-primary-focus-border: rgba(27, 31, 36, 0.15);
+        --color-btn-primary-focus-shadow: 0 0 0 3px rgba(45, 164, 78, 0.4);
+        --color-btn-primary-icon: rgba(255, 255, 255, 0.8);
+        --color-btn-primary-counter-bg: rgba(255, 255, 255, 0.2);
+        --color-btn-outline-text: #0969da;
+        --color-btn-outline-hover-text: #ffffff;
+        --color-btn-outline-hover-bg: #0969da;
+        --color-btn-outline-hover-border: rgba(27, 31, 36, 0.15);
+        --color-btn-outline-hover-shadow: 0 1px 0 rgba(27, 31, 36, 0.1);
+        --color-btn-outline-hover-inset-shadow: inset 0 1px 0
+          rgba(255, 255, 255, 0.03);
+        --color-btn-outline-hover-counter-bg: rgba(255, 255, 255, 0.2);
+        --color-btn-outline-selected-text: #ffffff;
+        --color-btn-outline-selected-bg: hsla(212, 92%, 42%, 1);
+        --color-btn-outline-selected-border: rgba(27, 31, 36, 0.15);
+        --color-btn-outline-selected-shadow: inset 0 1px 0 rgba(0, 33, 85, 0.2);
+        --color-btn-outline-disabled-text: rgba(9, 105, 218, 0.5);
+        --color-btn-outline-disabled-bg: #f6f8fa;
+        --color-btn-outline-disabled-counter-bg: rgba(9, 105, 218, 0.05);
+        --color-btn-outline-focus-border: rgba(27, 31, 36, 0.15);
+        --color-btn-outline-focus-shadow: 0 0 0 3px rgba(5, 80, 174, 0.4);
+        --color-btn-outline-counter-bg: rgba(9, 105, 218, 0.1);
+        --color-btn-danger-text: #cf222e;
+        --color-btn-danger-hover-text: #ffffff;
+        --color-btn-danger-hover-bg: #a40e26;
+        --color-btn-danger-hover-border: rgba(27, 31, 36, 0.15);
+        --color-btn-danger-hover-shadow: 0 1px 0 rgba(27, 31, 36, 0.1);
+        --color-btn-danger-hover-inset-shadow: inset 0 1px 0
+          rgba(255, 255, 255, 0.03);
+        --color-btn-danger-hover-counter-bg: rgba(255, 255, 255, 0.2);
+        --color-btn-danger-selected-text: #ffffff;
+        --color-btn-danger-selected-bg: hsla(356, 72%, 44%, 1);
+        --color-btn-danger-selected-border: rgba(27, 31, 36, 0.15);
+        --color-btn-danger-selected-shadow: inset 0 1px 0 rgba(76, 0, 20, 0.2);
+        --color-btn-danger-disabled-text: rgba(207, 34, 46, 0.5);
+        --color-btn-danger-disabled-bg: #f6f8fa;
+        --color-btn-danger-disabled-counter-bg: rgba(207, 34, 46, 0.05);
+        --color-btn-danger-focus-border: rgba(27, 31, 36, 0.15);
+        --color-btn-danger-focus-shadow: 0 0 0 3px rgba(164, 14, 38, 0.4);
+        --color-btn-danger-counter-bg: rgba(207, 34, 46, 0.1);
+        --color-btn-danger-icon: #cf222e;
+        --color-btn-danger-hover-icon: #ffffff;
+        --color-underlinenav-icon: #6e7781;
+        --color-underlinenav-border-hover: rgba(175, 184, 193, 0.2);
+        --color-fg-default: #24292f;
+        --color-fg-muted: #57606a;
+        --color-fg-subtle: #6e7781;
+        --color-fg-on-emphasis: #ffffff;
+        --color-canvas-default: #ffffff;
+        --color-canvas-overlay: #ffffff;
+        --color-canvas-inset: #f6f8fa;
+        --color-canvas-subtle: #f6f8fa;
+        --color-border-default: #d0d7de;
+        --color-border-muted: hsla(210, 18%, 87%, 1);
+        --color-border-subtle: rgba(27, 31, 36, 0.15);
+        --color-shadow-small: 0 1px 0 rgba(27, 31, 36, 0.04);
+        --color-shadow-medium: 0 3px 6px rgba(140, 149, 159, 0.15);
+        --color-shadow-large: 0 8px 24px rgba(140, 149, 159, 0.2);
+        --color-shadow-extra-large: 0 12px 28px rgba(140, 149, 159, 0.3);
+        --color-neutral-emphasis-plus: #24292f;
+        --color-neutral-emphasis: #6e7781;
+        --color-neutral-muted: rgba(175, 184, 193, 0.2);
+        --color-neutral-subtle: rgba(234, 238, 242, 0.5);
+        --color-accent-fg: #0969da;
+        --color-accent-emphasis: #0969da;
+        --color-accent-muted: rgba(84, 174, 255, 0.4);
+        --color-accent-subtle: #ddf4ff;
+        --color-success-fg: #1a7f37;
+        --color-success-emphasis: #2da44e;
+        --color-success-muted: rgba(74, 194, 107, 0.4);
+        --color-success-subtle: #dafbe1;
+        --color-attention-fg: #9a6700;
+        --color-attention-emphasis: #bf8700;
+        --color-attention-muted: rgba(212, 167, 44, 0.4);
+        --color-attention-subtle: #fff8c5;
+        --color-severe-fg: #bc4c00;
+        --color-severe-emphasis: #bc4c00;
+        --color-severe-muted: rgba(251, 143, 68, 0.4);
+        --color-severe-subtle: #fff1e5;
+        --color-danger-fg: #cf222e;
+        --color-danger-emphasis: #cf222e;
+        --color-danger-muted: rgba(255, 129, 130, 0.4);
+        --color-danger-subtle: #ffebe9;
+        --color-done-fg: #8250df;
+        --color-done-emphasis: #8250df;
+        --color-done-muted: rgba(194, 151, 255, 0.4);
+        --color-done-subtle: #fbefff;
+        --color-sponsors-fg: #bf3989;
+        --color-sponsors-emphasis: #bf3989;
+        --color-sponsors-muted: rgba(255, 128, 200, 0.4);
+        --color-sponsors-subtle: #ffeff7;
+        --color-primer-canvas-backdrop: rgba(27, 31, 36, 0.5);
+        --color-primer-canvas-sticky: rgba(255, 255, 255, 0.95);
+        --color-primer-border-active: #fd8c73;
+        --color-primer-border-contrast: rgba(27, 31, 36, 0.1);
+        --color-primer-shadow-highlight: inset 0 1px 0 rgba(255, 255, 255, 0.25);
+        --color-primer-shadow-inset: inset 0 1px 0 rgba(208, 215, 222, 0.2);
+        --color-primer-shadow-focus: 0 0 0 3px rgba(9, 105, 218, 0.3);
+        --color-scale-black: #1b1f24;
+        --color-scale-white: #ffffff;
+        --color-scale-gray-0: #f6f8fa;
+        --color-scale-gray-1: #eaeef2;
+        --color-scale-gray-2: #d0d7de;
+        --color-scale-gray-3: #afb8c1;
+        --color-scale-gray-4: #8c959f;
+        --color-scale-gray-5: #6e7781;
+        --color-scale-gray-6: #57606a;
+        --color-scale-gray-7: #424a53;
+        --color-scale-gray-8: #32383f;
+        --color-scale-gray-9: #24292f;
+        --color-scale-blue-0: #ddf4ff;
+        --color-scale-blue-1: #b6e3ff;
+        --color-scale-blue-2: #80ccff;
+        --color-scale-blue-3: #54aeff;
+        --color-scale-blue-4: #218bff;
+        --color-scale-blue-5: #0969da;
+        --color-scale-blue-6: #0550ae;
+        --color-scale-blue-7: #033d8b;
+        --color-scale-blue-8: #0a3069;
+        --color-scale-blue-9: #002155;
+        --color-scale-green-0: #dafbe1;
+        --color-scale-green-1: #aceebb;
+        --color-scale-green-2: #6fdd8b;
+        --color-scale-green-3: #4ac26b;
+        --color-scale-green-4: #2da44e;
+        --color-scale-green-5: #1a7f37;
+        --color-scale-green-6: #116329;
+        --color-scale-green-7: #044f1e;
+        --color-scale-green-8: #003d16;
+        --color-scale-green-9: #002d11;
+        --color-scale-yellow-0: #fff8c5;
+        --color-scale-yellow-1: #fae17d;
+        --color-scale-yellow-2: #eac54f;
+        --color-scale-yellow-3: #d4a72c;
+        --color-scale-yellow-4: #bf8700;
+        --color-scale-yellow-5: #9a6700;
+        --color-scale-yellow-6: #7d4e00;
+        --color-scale-yellow-7: #633c01;
+        --color-scale-yellow-8: #4d2d00;
+        --color-scale-yellow-9: #3b2300;
+        --color-scale-orange-0: #fff1e5;
+        --color-scale-orange-1: #ffd8b5;
+        --color-scale-orange-2: #ffb77c;
+        --color-scale-orange-3: #fb8f44;
+        --color-scale-orange-4: #e16f24;
+        --color-scale-orange-5: #bc4c00;
+        --color-scale-orange-6: #953800;
+        --color-scale-orange-7: #762c00;
+        --color-scale-orange-8: #5c2200;
+        --color-scale-orange-9: #471700;
+        --color-scale-red-0: #ffebe9;
+        --color-scale-red-1: #ffcecb;
+        --color-scale-red-2: #ffaba8;
+        --color-scale-red-3: #ff8182;
+        --color-scale-red-4: #fa4549;
+        --color-scale-red-5: #cf222e;
+        --color-scale-red-6: #a40e26;
+        --color-scale-red-7: #82071e;
+        --color-scale-red-8: #660018;
+        --color-scale-red-9: #4c0014;
+        --color-scale-purple-0: #fbefff;
+        --color-scale-purple-1: #ecd8ff;
+        --color-scale-purple-2: #d8b9ff;
+        --color-scale-purple-3: #c297ff;
+        --color-scale-purple-4: #a475f9;
+        --color-scale-purple-5: #8250df;
+        --color-scale-purple-6: #6639ba;
+        --color-scale-purple-7: #512a97;
+        --color-scale-purple-8: #3e1f79;
+        --color-scale-purple-9: #2e1461;
+        --color-scale-pink-0: #ffeff7;
+        --color-scale-pink-1: #ffd3eb;
+        --color-scale-pink-2: #ffadda;
+        --color-scale-pink-3: #ff80c8;
+        --color-scale-pink-4: #e85aad;
+        --color-scale-pink-5: #bf3989;
+        --color-scale-pink-6: #99286e;
+        --color-scale-pink-7: #772057;
+        --color-scale-pink-8: #611347;
+        --color-scale-pink-9: #4d0336;
+        --color-scale-coral-0: #fff0eb;
+        --color-scale-coral-1: #ffd6cc;
+        --color-scale-coral-2: #ffb4a1;
+        --color-scale-coral-3: #fd8c73;
+        --color-scale-coral-4: #ec6547;
+        --color-scale-coral-5: #c4432b;
+        --color-scale-coral-6: #9e2f1c;
+        --color-scale-coral-7: #801f0f;
+        --color-scale-coral-8: #691105;
+        --color-scale-coral-9: #510901;
+      }
+      :root.dark-mode {
+        color-scheme: dark;
+        --color-canvas-default-transparent: rgba(13, 17, 23, 0);
+        --color-marketing-icon-primary: #79c0ff;
+        --color-marketing-icon-secondary: #1f6feb;
+        --color-diff-blob-addition-num-text: #c9d1d9;
+        --color-diff-blob-addition-fg: #c9d1d9;
+        --color-diff-blob-addition-num-bg: rgba(63, 185, 80, 0.3);
+        --color-diff-blob-addition-line-bg: rgba(46, 160, 67, 0.15);
+        --color-diff-blob-addition-word-bg: rgba(46, 160, 67, 0.4);
+        --color-diff-blob-deletion-num-text: #c9d1d9;
+        --color-diff-blob-deletion-fg: #c9d1d9;
+        --color-diff-blob-deletion-num-bg: rgba(248, 81, 73, 0.3);
+        --color-diff-blob-deletion-line-bg: rgba(248, 81, 73, 0.15);
+        --color-diff-blob-deletion-word-bg: rgba(248, 81, 73, 0.4);
+        --color-diff-blob-hunk-num-bg: rgba(56, 139, 253, 0.4);
+        --color-diff-blob-expander-icon: #8b949e;
+        --color-diff-blob-selected-line-highlight-mix-blend-mode: screen;
+        --color-diffstat-deletion-border: rgba(240, 246, 252, 0.1);
+        --color-diffstat-addition-border: rgba(240, 246, 252, 0.1);
+        --color-diffstat-addition-bg: #3fb950;
+        --color-search-keyword-hl: rgba(210, 153, 34, 0.4);
+        --color-prettylights-syntax-comment: #8b949e;
+        --color-prettylights-syntax-constant: #79c0ff;
+        --color-prettylights-syntax-entity: #d2a8ff;
+        --color-prettylights-syntax-storage-modifier-import: #c9d1d9;
+        --color-prettylights-syntax-entity-tag: #7ee787;
+        --color-prettylights-syntax-keyword: #ff7b72;
+        --color-prettylights-syntax-string: #a5d6ff;
+        --color-prettylights-syntax-variable: #ffa657;
+        --color-prettylights-syntax-brackethighlighter-unmatched: #f85149;
+        --color-prettylights-syntax-invalid-illegal-text: #f0f6fc;
+        --color-prettylights-syntax-invalid-illegal-bg: #8e1519;
+        --color-prettylights-syntax-carriage-return-text: #f0f6fc;
+        --color-prettylights-syntax-carriage-return-bg: #b62324;
+        --color-prettylights-syntax-string-regexp: #7ee787;
+        --color-prettylights-syntax-markup-list: #f2cc60;
+        --color-prettylights-syntax-markup-heading: #1f6feb;
+        --color-prettylights-syntax-markup-italic: #c9d1d9;
+        --color-prettylights-syntax-markup-bold: #c9d1d9;
+        --color-prettylights-syntax-markup-deleted-text: #ffdcd7;
+        --color-prettylights-syntax-markup-deleted-bg: #67060c;
+        --color-prettylights-syntax-markup-inserted-text: #aff5b4;
+        --color-prettylights-syntax-markup-inserted-bg: #033a16;
+        --color-prettylights-syntax-markup-changed-text: #ffdfb6;
+        --color-prettylights-syntax-markup-changed-bg: #5a1e02;
+        --color-prettylights-syntax-markup-ignored-text: #c9d1d9;
+        --color-prettylights-syntax-markup-ignored-bg: #1158c7;
+        --color-prettylights-syntax-meta-diff-range: #d2a8ff;
+        --color-prettylights-syntax-brackethighlighter-angle: #8b949e;
+        --color-prettylights-syntax-sublimelinter-gutter-mark: #484f58;
+        --color-prettylights-syntax-constant-other-reference-link: #a5d6ff;
+        --color-codemirror-text: #c9d1d9;
+        --color-codemirror-bg: #0d1117;
+        --color-codemirror-gutters-bg: #0d1117;
+        --color-codemirror-guttermarker-text: #0d1117;
+        --color-codemirror-guttermarker-subtle-text: #484f58;
+        --color-codemirror-linenumber-text: #8b949e;
+        --color-codemirror-cursor: #c9d1d9;
+        --color-codemirror-selection-bg: rgba(56, 139, 253, 0.4);
+        --color-codemirror-activeline-bg: rgba(110, 118, 129, 0.1);
+        --color-codemirror-matchingbracket-text: #c9d1d9;
+        --color-codemirror-lines-bg: #0d1117;
+        --color-codemirror-syntax-comment: #8b949e;
+        --color-codemirror-syntax-constant: #79c0ff;
+        --color-codemirror-syntax-entity: #d2a8ff;
+        --color-codemirror-syntax-keyword: #ff7b72;
+        --color-codemirror-syntax-storage: #ff7b72;
+        --color-codemirror-syntax-string: #a5d6ff;
+        --color-codemirror-syntax-support: #79c0ff;
+        --color-codemirror-syntax-variable: #ffa657;
+        --color-checks-bg: #010409;
+        --color-checks-run-border-width: 1px;
+        --color-checks-container-border-width: 1px;
+        --color-checks-text-primary: #c9d1d9;
+        --color-checks-text-secondary: #8b949e;
+        --color-checks-text-link: #58a6ff;
+        --color-checks-btn-icon: #8b949e;
+        --color-checks-btn-hover-icon: #c9d1d9;
+        --color-checks-btn-hover-bg: rgba(110, 118, 129, 0.1);
+        --color-checks-input-text: #8b949e;
+        --color-checks-input-placeholder-text: #484f58;
+        --color-checks-input-focus-text: #c9d1d9;
+        --color-checks-input-bg: #161b22;
+        --color-checks-input-shadow: none;
+        --color-checks-donut-error: #f85149;
+        --color-checks-donut-pending: #d29922;
+        --color-checks-donut-success: #2ea043;
+        --color-checks-donut-neutral: #8b949e;
+        --color-checks-dropdown-text: #c9d1d9;
+        --color-checks-dropdown-bg: #161b22;
+        --color-checks-dropdown-border: #30363d;
+        --color-checks-dropdown-shadow: rgba(1, 4, 9, 0.3);
+        --color-checks-dropdown-hover-text: #c9d1d9;
+        --color-checks-dropdown-hover-bg: rgba(110, 118, 129, 0.1);
+        --color-checks-dropdown-btn-hover-text: #c9d1d9;
+        --color-checks-dropdown-btn-hover-bg: rgba(110, 118, 129, 0.1);
+        --color-checks-scrollbar-thumb-bg: rgba(110, 118, 129, 0.4);
+        --color-checks-header-label-text: #8b949e;
+        --color-checks-header-label-open-text: #c9d1d9;
+        --color-checks-header-border: #21262d;
+        --color-checks-header-icon: #8b949e;
+        --color-checks-line-text: #8b949e;
+        --color-checks-line-num-text: #484f58;
+        --color-checks-line-timestamp-text: #484f58;
+        --color-checks-line-hover-bg: rgba(110, 118, 129, 0.1);
+        --color-checks-line-selected-bg: rgba(56, 139, 253, 0.15);
+        --color-checks-line-selected-num-text: #58a6ff;
+        --color-checks-line-dt-fm-text: #f0f6fc;
+        --color-checks-line-dt-fm-bg: #9e6a03;
+        --color-checks-gate-bg: rgba(187, 128, 9, 0.15);
+        --color-checks-gate-text: #8b949e;
+        --color-checks-gate-waiting-text: #d29922;
+        --color-checks-step-header-open-bg: #161b22;
+        --color-checks-step-error-text: #f85149;
+        --color-checks-step-warning-text: #d29922;
+        --color-checks-logline-text: #8b949e;
+        --color-checks-logline-num-text: #484f58;
+        --color-checks-logline-debug-text: #a371f7;
+        --color-checks-logline-error-text: #8b949e;
+        --color-checks-logline-error-num-text: #484f58;
+        --color-checks-logline-error-bg: rgba(248, 81, 73, 0.15);
+        --color-checks-logline-warning-text: #8b949e;
+        --color-checks-logline-warning-num-text: #d29922;
+        --color-checks-logline-warning-bg: rgba(187, 128, 9, 0.15);
+        --color-checks-logline-command-text: #58a6ff;
+        --color-checks-logline-section-text: #3fb950;
+        --color-checks-ansi-black: #0d1117;
+        --color-checks-ansi-black-bright: #161b22;
+        --color-checks-ansi-white: #b1bac4;
+        --color-checks-ansi-white-bright: #b1bac4;
+        --color-checks-ansi-gray: #6e7681;
+        --color-checks-ansi-red: #ff7b72;
+        --color-checks-ansi-red-bright: #ffa198;
+        --color-checks-ansi-green: #3fb950;
+        --color-checks-ansi-green-bright: #56d364;
+        --color-checks-ansi-yellow: #d29922;
+        --color-checks-ansi-yellow-bright: #e3b341;
+        --color-checks-ansi-blue: #58a6ff;
+        --color-checks-ansi-blue-bright: #79c0ff;
+        --color-checks-ansi-magenta: #bc8cff;
+        --color-checks-ansi-magenta-bright: #d2a8ff;
+        --color-checks-ansi-cyan: #76e3ea;
+        --color-checks-ansi-cyan-bright: #b3f0ff;
+        --color-project-header-bg: #0d1117;
+        --color-project-sidebar-bg: #161b22;
+        --color-project-gradient-in: #161b22;
+        --color-project-gradient-out: rgba(22, 27, 34, 0);
+        --color-mktg-success: rgba(41, 147, 61, 1);
+        --color-mktg-info: rgba(42, 123, 243, 1);
+        --color-mktg-bg-shade-gradient-top: rgba(1, 4, 9, 0.065);
+        --color-mktg-bg-shade-gradient-bottom: rgba(1, 4, 9, 0);
+        --color-mktg-btn-bg-top: hsla(228, 82%, 66%, 1);
+        --color-mktg-btn-bg-bottom: #4969ed;
+        --color-mktg-btn-bg-overlay-top: hsla(228, 74%, 59%, 1);
+        --color-mktg-btn-bg-overlay-bottom: #3355e0;
+        --color-mktg-btn-text: #f0f6fc;
+        --color-mktg-btn-primary-bg-top: hsla(137, 56%, 46%, 1);
+        --color-mktg-btn-primary-bg-bottom: #2ea44f;
+        --color-mktg-btn-primary-bg-overlay-top: hsla(134, 60%, 38%, 1);
+        --color-mktg-btn-primary-bg-overlay-bottom: #22863a;
+        --color-mktg-btn-primary-text: #f0f6fc;
+        --color-mktg-btn-enterprise-bg-top: hsla(249, 100%, 72%, 1);
+        --color-mktg-btn-enterprise-bg-bottom: #6f57ff;
+        --color-mktg-btn-enterprise-bg-overlay-top: hsla(248, 65%, 63%, 1);
+        --color-mktg-btn-enterprise-bg-overlay-bottom: #614eda;
+        --color-mktg-btn-enterprise-text: #f0f6fc;
+        --color-mktg-btn-outline-text: #f0f6fc;
+        --color-mktg-btn-outline-border: rgba(240, 246, 252, 0.3);
+        --color-mktg-btn-outline-hover-text: #f0f6fc;
+        --color-mktg-btn-outline-hover-border: rgba(240, 246, 252, 0.5);
+        --color-mktg-btn-outline-focus-border: #f0f6fc;
+        --color-mktg-btn-outline-focus-border-inset: rgba(240, 246, 252, 0.5);
+        --color-mktg-btn-dark-text: #f0f6fc;
+        --color-mktg-btn-dark-border: rgba(240, 246, 252, 0.3);
+        --color-mktg-btn-dark-hover-text: #f0f6fc;
+        --color-mktg-btn-dark-hover-border: rgba(240, 246, 252, 0.5);
+        --color-mktg-btn-dark-focus-border: #f0f6fc;
+        --color-mktg-btn-dark-focus-border-inset: rgba(240, 246, 252, 0.5);
+        --color-avatar-bg: rgba(240, 246, 252, 0.1);
+        --color-avatar-border: rgba(240, 246, 252, 0.1);
+        --color-avatar-stack-fade: #30363d;
+        --color-avatar-stack-fade-more: #21262d;
+        --color-avatar-child-shadow: -2px -2px 0 #0d1117;
+        --color-topic-tag-border: rgba(0, 0, 0, 0);
+        --color-select-menu-backdrop-border: #484f58;
+        --color-select-menu-tap-highlight: rgba(48, 54, 61, 0.5);
+        --color-select-menu-tap-focus-bg: #0c2d6b;
+        --color-overlay-shadow:
+          0 0 0 1px #30363d, 0 16px 32px rgba(1, 4, 9, 0.85);
+        --color-header-text: rgba(240, 246, 252, 0.7);
+        --color-header-bg: #161b22;
+        --color-header-logo: #f0f6fc;
+        --color-header-search-bg: #0d1117;
+        --color-header-search-border: #30363d;
+        --color-sidenav-selected-bg: #21262d;
+        --color-menu-bg-active: #161b22;
+        --color-control-transparent-bg-hover: #656c7633;
+        --color-input-disabled-bg: rgba(110, 118, 129, 0);
+        --color-timeline-badge-bg: #21262d;
+        --color-ansi-black: #484f58;
+        --color-ansi-black-bright: #6e7681;
+        --color-ansi-white: #b1bac4;
+        --color-ansi-white-bright: #f0f6fc;
+        --color-ansi-gray: #6e7681;
+        --color-ansi-red: #ff7b72;
+        --color-ansi-red-bright: #ffa198;
+        --color-ansi-green: #3fb950;
+        --color-ansi-green-bright: #56d364;
+        --color-ansi-yellow: #d29922;
+        --color-ansi-yellow-bright: #e3b341;
+        --color-ansi-blue: #58a6ff;
+        --color-ansi-blue-bright: #79c0ff;
+        --color-ansi-magenta: #bc8cff;
+        --color-ansi-magenta-bright: #d2a8ff;
+        --color-ansi-cyan: #39c5cf;
+        --color-ansi-cyan-bright: #56d4dd;
+        --color-btn-text: #c9d1d9;
+        --color-btn-bg: #21262d;
+        --color-btn-border: rgba(240, 246, 252, 0.1);
+        --color-btn-shadow: 0 0 transparent;
+        --color-btn-inset-shadow: 0 0 transparent;
+        --color-btn-hover-bg: #30363d;
+        --color-btn-hover-border: #8b949e;
+        --color-btn-active-bg: hsla(212, 12%, 18%, 1);
+        --color-btn-active-border: #6e7681;
+        --color-btn-selected-bg: #161b22;
+        --color-btn-focus-bg: #21262d;
+        --color-btn-focus-border: #8b949e;
+        --color-btn-focus-shadow: 0 0 0 3px rgba(139, 148, 158, 0.3);
+        --color-btn-shadow-active: inset 0 0.15em 0.3em rgba(1, 4, 9, 0.15);
+        --color-btn-shadow-input-focus: 0 0 0 0.2em rgba(31, 111, 235, 0.3);
+        --color-btn-counter-bg: #30363d;
+        --color-btn-primary-text: #ffffff;
+        --color-btn-primary-bg: #238636;
+        --color-btn-primary-border: rgba(240, 246, 252, 0.1);
+        --color-btn-primary-shadow: 0 0 transparent;
+        --color-btn-primary-inset-shadow: 0 0 transparent;
+        --color-btn-primary-hover-bg: #2ea043;
+        --color-btn-primary-hover-border: rgba(240, 246, 252, 0.1);
+        --color-btn-primary-selected-bg: #238636;
+        --color-btn-primary-selected-shadow: 0 0 transparent;
+        --color-btn-primary-disabled-text: rgba(240, 246, 252, 0.5);
+        --color-btn-primary-disabled-bg: rgba(35, 134, 54, 0.6);
+        --color-btn-primary-disabled-border: rgba(240, 246, 252, 0.1);
+        --color-btn-primary-focus-bg: #238636;
+        --color-btn-primary-focus-border: rgba(240, 246, 252, 0.1);
+        --color-btn-primary-focus-shadow: 0 0 0 3px rgba(46, 164, 79, 0.4);
+        --color-btn-primary-icon: #f0f6fc;
+        --color-btn-primary-counter-bg: rgba(240, 246, 252, 0.2);
+        --color-btn-outline-text: #58a6ff;
+        --color-btn-outline-hover-text: #58a6ff;
+        --color-btn-outline-hover-bg: #30363d;
+        --color-btn-outline-hover-border: rgba(240, 246, 252, 0.1);
+        --color-btn-outline-hover-shadow: 0 1px 0 rgba(1, 4, 9, 0.1);
+        --color-btn-outline-hover-inset-shadow: inset 0 1px 0
+          rgba(240, 246, 252, 0.03);
+        --color-btn-outline-hover-counter-bg: rgba(240, 246, 252, 0.2);
+        --color-btn-outline-selected-text: #f0f6fc;
+        --color-btn-outline-selected-bg: #0d419d;
+        --color-btn-outline-selected-border: rgba(240, 246, 252, 0.1);
+        --color-btn-outline-selected-shadow: 0 0 transparent;
+        --color-btn-outline-disabled-text: rgba(88, 166, 255, 0.5);
+        --color-btn-outline-disabled-bg: #0d1117;
+        --color-btn-outline-disabled-counter-bg: rgba(31, 111, 235, 0.05);
+        --color-btn-outline-focus-border: rgba(240, 246, 252, 0.1);
+        --color-btn-outline-focus-shadow: 0 0 0 3px rgba(17, 88, 199, 0.4);
+        --color-btn-outline-counter-bg: rgba(31, 111, 235, 0.1);
+        --color-btn-danger-text: #f85149;
+        --color-btn-danger-hover-text: #f0f6fc;
+        --color-btn-danger-hover-bg: #da3633;
+        --color-btn-danger-hover-border: #f85149;
+        --color-btn-danger-hover-shadow: 0 0 transparent;
+        --color-btn-danger-hover-inset-shadow: 0 0 transparent;
+        --color-btn-danger-hover-icon: #f0f6fc;
+        --color-btn-danger-hover-counter-bg: rgba(255, 255, 255, 0.2);
+        --color-btn-danger-selected-text: #ffffff;
+        --color-btn-danger-selected-bg: #b62324;
+        --color-btn-danger-selected-border: #ff7b72;
+        --color-btn-danger-selected-shadow: 0 0 transparent;
+        --color-btn-danger-disabled-text: rgba(248, 81, 73, 0.5);
+        --color-btn-danger-disabled-bg: #0d1117;
+        --color-btn-danger-disabled-counter-bg: rgba(218, 54, 51, 0.05);
+        --color-btn-danger-focus-border: #f85149;
+        --color-btn-danger-focus-shadow: 0 0 0 3px rgba(248, 81, 73, 0.4);
+        --color-btn-danger-counter-bg: rgba(218, 54, 51, 0.1);
+        --color-btn-danger-icon: #f85149;
+        --color-underlinenav-icon: #484f58;
+        --color-underlinenav-border-hover: rgba(110, 118, 129, 0.4);
+        --color-fg-default: #c9d1d9;
+        --color-fg-muted: #8b949e;
+        --color-fg-subtle: #484f58;
+        --color-fg-on-emphasis: #f0f6fc;
+        --color-canvas-default: #0d1117;
+        --color-canvas-overlay: #161b22;
+        --color-canvas-inset: #010409;
+        --color-canvas-subtle: #161b22;
+        --color-border-default: #30363d;
+        --color-border-muted: #21262d;
+        --color-border-subtle: rgba(240, 246, 252, 0.1);
+        --color-shadow-small: 0 0 transparent;
+        --color-shadow-medium: 0 3px 6px #010409;
+        --color-shadow-large: 0 8px 24px #010409;
+        --color-shadow-extra-large: 0 12px 48px #010409;
+        --color-neutral-emphasis-plus: #6e7681;
+        --color-neutral-emphasis: #6e7681;
+        --color-neutral-muted: rgba(110, 118, 129, 0.4);
+        --color-neutral-subtle: rgba(110, 118, 129, 0.1);
+        --color-accent-fg: #58a6ff;
+        --color-accent-emphasis: #1f6feb;
+        --color-accent-muted: rgba(56, 139, 253, 0.4);
+        --color-accent-subtle: rgba(56, 139, 253, 0.15);
+        --color-success-fg: #3fb950;
+        --color-success-emphasis: #238636;
+        --color-success-muted: rgba(46, 160, 67, 0.4);
+        --color-success-subtle: rgba(46, 160, 67, 0.15);
+        --color-attention-fg: #d29922;
+        --color-attention-emphasis: #9e6a03;
+        --color-attention-muted: rgba(187, 128, 9, 0.4);
+        --color-attention-subtle: rgba(187, 128, 9, 0.15);
+        --color-severe-fg: #db6d28;
+        --color-severe-emphasis: #bd561d;
+        --color-severe-muted: rgba(219, 109, 40, 0.4);
+        --color-severe-subtle: rgba(219, 109, 40, 0.15);
+        --color-danger-fg: #f85149;
+        --color-danger-emphasis: #da3633;
+        --color-danger-muted: rgba(248, 81, 73, 0.4);
+        --color-danger-subtle: rgba(248, 81, 73, 0.15);
+        --color-done-fg: #a371f7;
+        --color-done-emphasis: #8957e5;
+        --color-done-muted: rgba(163, 113, 247, 0.4);
+        --color-done-subtle: rgba(163, 113, 247, 0.15);
+        --color-sponsors-fg: #db61a2;
+        --color-sponsors-emphasis: #bf4b8a;
+        --color-sponsors-muted: rgba(219, 97, 162, 0.4);
+        --color-sponsors-subtle: rgba(219, 97, 162, 0.15);
+        --color-primer-canvas-backdrop: rgba(1, 4, 9, 0.8);
+        --color-primer-canvas-sticky: rgba(13, 17, 23, 0.95);
+        --color-primer-border-active: #f78166;
+        --color-primer-border-contrast: rgba(240, 246, 252, 0.2);
+        --color-primer-shadow-highlight: 0 0 transparent;
+        --color-primer-shadow-inset: 0 0 transparent;
+        --color-primer-shadow-focus: 0 0 0 3px #0c2d6b;
+        --color-scale-black: #010409;
+        --color-scale-white: #f0f6fc;
+        --color-scale-gray-0: #f0f6fc;
+        --color-scale-gray-1: #c9d1d9;
+        --color-scale-gray-2: #b1bac4;
+        --color-scale-gray-3: #8b949e;
+        --color-scale-gray-4: #6e7681;
+        --color-scale-gray-5: #484f58;
+        --color-scale-gray-6: #30363d;
+        --color-scale-gray-7: #21262d;
+        --color-scale-gray-8: #161b22;
+        --color-scale-gray-9: #0d1117;
+        --color-scale-blue-0: #cae8ff;
+        --color-scale-blue-1: #a5d6ff;
+        --color-scale-blue-2: #79c0ff;
+        --color-scale-blue-3: #58a6ff;
+        --color-scale-blue-4: #388bfd;
+        --color-scale-blue-5: #1f6feb;
+        --color-scale-blue-6: #1158c7;
+        --color-scale-blue-7: #0d419d;
+        --color-scale-blue-8: #0c2d6b;
+        --color-scale-blue-9: #051d4d;
+        --color-scale-green-0: #aff5b4;
+        --color-scale-green-1: #7ee787;
+        --color-scale-green-2: #56d364;
+        --color-scale-green-3: #3fb950;
+        --color-scale-green-4: #2ea043;
+        --color-scale-green-5: #238636;
+        --color-scale-green-6: #196c2e;
+        --color-scale-green-7: #0f5323;
+        --color-scale-green-8: #033a16;
+        --color-scale-green-9: #04260f;
+        --color-scale-yellow-0: #f8e3a1;
+        --color-scale-yellow-1: #f2cc60;
+        --color-scale-yellow-2: #e3b341;
+        --color-scale-yellow-3: #d29922;
+        --color-scale-yellow-4: #bb8009;
+        --color-scale-yellow-5: #9e6a03;
+        --color-scale-yellow-6: #845306;
+        --color-scale-yellow-7: #693e00;
+        --color-scale-yellow-8: #4b2900;
+        --color-scale-yellow-9: #341a00;
+        --color-scale-orange-0: #ffdfb6;
+        --color-scale-orange-1: #ffc680;
+        --color-scale-orange-2: #ffa657;
+        --color-scale-orange-3: #f0883e;
+        --color-scale-orange-4: #db6d28;
+        --color-scale-orange-5: #bd561d;
+        --color-scale-orange-6: #9b4215;
+        --color-scale-orange-7: #762d0a;
+        --color-scale-orange-8: #5a1e02;
+        --color-scale-orange-9: #3d1300;
+        --color-scale-red-0: #ffdcd7;
+        --color-scale-red-1: #ffc1ba;
+        --color-scale-red-2: #ffa198;
+        --color-scale-red-3: #ff7b72;
+        --color-scale-red-4: #f85149;
+        --color-scale-red-5: #da3633;
+        --color-scale-red-6: #b62324;
+        --color-scale-red-7: #8e1519;
+        --color-scale-red-8: #67060c;
+        --color-scale-red-9: #490202;
+        --color-scale-purple-0: #eddeff;
+        --color-scale-purple-1: #e2c5ff;
+        --color-scale-purple-2: #d2a8ff;
+        --color-scale-purple-3: #bc8cff;
+        --color-scale-purple-4: #a371f7;
+        --color-scale-purple-5: #8957e5;
+        --color-scale-purple-6: #6e40c9;
+        --color-scale-purple-7: #553098;
+        --color-scale-purple-8: #3c1e70;
+        --color-scale-purple-9: #271052;
+        --color-scale-pink-0: #ffdaec;
+        --color-scale-pink-1: #ffbedd;
+        --color-scale-pink-2: #ff9bce;
+        --color-scale-pink-3: #f778ba;
+        --color-scale-pink-4: #db61a2;
+        --color-scale-pink-5: #bf4b8a;
+        --color-scale-pink-6: #9e3670;
+        --color-scale-pink-7: #7d2457;
+        --color-scale-pink-8: #5e103e;
+        --color-scale-pink-9: #42062a;
+        --color-scale-coral-0: #ffddd2;
+        --color-scale-coral-1: #ffc2b2;
+        --color-scale-coral-2: #ffa28b;
+        --color-scale-coral-3: #f78166;
+        --color-scale-coral-4: #ea6045;
+        --color-scale-coral-5: #cf462d;
+        --color-scale-coral-6: #ac3220;
+        --color-scale-coral-7: #872012;
+        --color-scale-coral-8: #640d04;
+        --color-scale-coral-9: #460701;
+      }
+      :root {
+        --box-shadow:
+          rgba(0, 0, 0, 0.133) 0px 1.6px 3.6px 0px,
+          rgba(0, 0, 0, 0.11) 0px 0.3px 0.9px 0px;
+        --box-shadow-thick:
+          rgb(0 0 0 / 10%) 0px 1.8px 1.9px, rgb(0 0 0 / 15%) 0px 6.1px 6.3px,
+          rgb(0 0 0 / 10%) 0px -2px 4px, rgb(0 0 0 / 15%) 0px -6.1px 12px,
+          rgb(0 0 0 / 25%) 0px 6px 12px;
+      }
+      * {
+        box-sizing: border-box;
+        min-width: 0;
+        min-height: 0;
+      }
+      svg {
+        fill: currentColor;
+      }
+      .vbox {
+        display: flex;
+        flex-direction: column;
+        flex: auto;
+        position: relative;
+      }
+      .hbox {
+        display: flex;
+        flex: auto;
+        position: relative;
+      }
+      .hidden {
+        visibility: hidden;
+      }
+      .d-flex {
+        display: flex !important;
+      }
+      .d-inline {
+        display: inline !important;
+      }
+      .m-1 {
+        margin: 4px;
+      }
+      .m-2 {
+        margin: 8px;
+      }
+      .m-3 {
+        margin: 16px;
+      }
+      .m-4 {
+        margin: 24px;
+      }
+      .m-5 {
+        margin: 32px;
+      }
+      .mx-1 {
+        margin: 0 4px;
+      }
+      .mx-2 {
+        margin: 0 8px;
+      }
+      .mx-3 {
+        margin: 0 16px;
+      }
+      .mx-4 {
+        margin: 0 24px;
+      }
+      .mx-5 {
+        margin: 0 32px;
+      }
+      .my-1 {
+        margin: 4px 0;
+      }
+      .my-2 {
+        margin: 8px 0;
+      }
+      .my-3 {
+        margin: 16px 0;
+      }
+      .my-4 {
+        margin: 24px 0;
+      }
+      .my-5 {
+        margin: 32px 0;
+      }
+      .mt-1 {
+        margin-top: 4px;
+      }
+      .mt-2 {
+        margin-top: 8px;
+      }
+      .mt-3 {
+        margin-top: 16px;
+      }
+      .mt-4 {
+        margin-top: 24px;
+      }
+      .mt-5 {
+        margin-top: 32px;
+      }
+      .mr-1 {
+        margin-right: 4px;
+      }
+      .mr-2 {
+        margin-right: 8px;
+      }
+      .mr-3 {
+        margin-right: 16px;
+      }
+      .mr-4 {
+        margin-right: 24px;
+      }
+      .mr-5 {
+        margin-right: 32px;
+      }
+      .mb-1 {
+        margin-bottom: 4px;
+      }
+      .mb-2 {
+        margin-bottom: 8px;
+      }
+      .mb-3 {
+        margin-bottom: 16px;
+      }
+      .mb-4 {
+        margin-bottom: 24px;
+      }
+      .mb-5 {
+        margin-bottom: 32px;
+      }
+      .ml-1 {
+        margin-left: 4px;
+      }
+      .ml-2 {
+        margin-left: 8px;
+      }
+      .ml-3 {
+        margin-left: 16px;
+      }
+      .ml-4 {
+        margin-left: 24px;
+      }
+      .ml-5 {
+        margin-left: 32px;
+      }
+      .p-1 {
+        padding: 4px;
+      }
+      .p-2 {
+        padding: 8px;
+      }
+      .p-3 {
+        padding: 16px;
+      }
+      .p-4 {
+        padding: 24px;
+      }
+      .p-5 {
+        padding: 32px;
+      }
+      .px-1 {
+        padding: 0 4px;
+      }
+      .px-2 {
+        padding: 0 8px;
+      }
+      .px-3 {
+        padding: 0 16px;
+      }
+      .px-4 {
+        padding: 0 24px;
+      }
+      .px-5 {
+        padding: 0 32px;
+      }
+      .py-1 {
+        padding: 4px 0;
+      }
+      .py-2 {
+        padding: 8px 0;
+      }
+      .py-3 {
+        padding: 16px 0;
+      }
+      .py-4 {
+        padding: 24px 0;
+      }
+      .py-5 {
+        padding: 32px 0;
+      }
+      .pt-1 {
+        padding-top: 4px;
+      }
+      .pt-2 {
+        padding-top: 8px;
+      }
+      .pt-3 {
+        padding-top: 16px;
+      }
+      .pt-4 {
+        padding-top: 24px;
+      }
+      .pt-5 {
+        padding-top: 32px;
+      }
+      .pr-1 {
+        padding-right: 4px;
+      }
+      .pr-2 {
+        padding-right: 8px;
+      }
+      .pr-3 {
+        padding-right: 16px;
+      }
+      .pr-4 {
+        padding-right: 24px;
+      }
+      .pr-5 {
+        padding-right: 32px;
+      }
+      .pb-1 {
+        padding-bottom: 4px;
+      }
+      .pb-2 {
+        padding-bottom: 8px;
+      }
+      .pb-3 {
+        padding-bottom: 16px;
+      }
+      .pb-4 {
+        padding-bottom: 24px;
+      }
+      .pb-5 {
+        padding-bottom: 32px;
+      }
+      .pl-1 {
+        padding-left: 4px;
+      }
+      .pl-2 {
+        padding-left: 8px;
+      }
+      .pl-3 {
+        padding-left: 16px;
+      }
+      .pl-4 {
+        padding-left: 24px;
+      }
+      .pl-5 {
+        padding-left: 32px;
+      }
+      .no-wrap {
+        white-space: nowrap !important;
+      }
+      .float-left {
+        float: left !important;
+      }
+      article,
+      aside,
+      details,
+      figcaption,
+      figure,
+      footer,
+      header,
+      main,
+      menu,
+      nav,
+      section {
+        display: block;
+      }
+      .form-control,
+      .form-select {
+        padding: 5px 12px;
+        font-size: 14px;
+        line-height: 20px;
+        color: var(--color-fg-default);
+        vertical-align: middle;
+        background-color: var(--color-canvas-default);
+        background-repeat: no-repeat;
+        background-position: right 8px center;
+        border: 1px solid var(--color-border-default);
+        border-radius: 6px;
+        outline: none;
+        box-shadow: var(--color-primer-shadow-inset);
+      }
+      .input-contrast {
+        background-color: var(--color-canvas-inset);
+      }
+      .subnav-search {
+        position: relative;
+        flex: auto;
+        display: flex;
+      }
+      .subnav-search-input {
+        flex: auto;
+        padding-left: 32px;
+        color: var(--color-fg-muted);
+      }
+      .subnav-search-icon {
+        position: absolute;
+        top: 9px;
+        left: 8px;
+        display: block;
+        color: var(--color-fg-muted);
+        text-align: center;
+        pointer-events: none;
+      }
+      .subnav-search-context + .subnav-search {
+        margin-left: -1px;
+      }
+      .subnav-item {
+        flex: none;
+        position: relative;
+        float: left;
+        padding: 5px 8px;
+        font-weight: 500;
+        line-height: 20px;
+        color: var(--color-fg-default);
+        border: 1px solid var(--color-border-default);
+        -webkit-user-select: none;
+        user-select: none;
+      }
+      .subnav-item:hover {
+        background-color: var(--color-canvas-subtle);
+      }
+      .subnav-item[aria-selected='true'] {
+        background: var(--color-control-transparent-bg-hover);
+      }
+      .subnav-item:first-child {
+        border-top-left-radius: 6px;
+        border-bottom-left-radius: 6px;
+      }
+      .subnav-item:last-child {
+        border-top-right-radius: 6px;
+        border-bottom-right-radius: 6px;
+      }
+      .subnav-item + .subnav-item {
+        margin-left: -1px;
+      }
+      .subnav-item .octicon,
+      .subnav-item-label {
+        margin-right: 8px;
+      }
+      .counter {
+        display: inline-block;
+        min-width: 20px;
+        padding: 0 6px;
+        font-size: 12px;
+        font-weight: 500;
+        line-height: 18px;
+        color: var(--color-fg-default);
+        text-align: center;
+        background-color: var(--color-neutral-muted);
+        border: 1px solid transparent;
+        border-radius: 2em;
+      }
+      .color-icon-success {
+        color: var(--color-success-fg) !important;
+      }
+      .color-text-danger {
+        color: var(--color-danger-fg) !important;
+      }
+      .color-text-warning {
+        color: var(--color-checks-step-warning-text) !important;
+      }
+      .color-fg-muted {
+        color: var(--color-fg-muted) !important;
+      }
+      .octicon {
+        display: inline-block;
+        overflow: visible !important;
+        vertical-align: text-bottom;
+        fill: currentColor;
+        margin-right: 7px;
+        flex: none;
+      }
+      .button {
+        flex: none;
+        height: 24px;
+        border: 1px solid var(--color-btn-border);
+        outline: none;
+        color: var(--color-btn-text);
+        background: var(--color-btn-bg);
+        padding: 4px;
+        cursor: pointer;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        border-radius: 4px;
+      }
+      .button:not(:disabled):hover {
+        border-color: var(--color-btn-hover-border);
+        background-color: var(--color-btn-hover-bg);
+      }
+      input[type='checkbox'] {
+        outline: var(--color-focus-border);
+        height: 24px;
+      }
+      dialog {
+        background-color: var(--color-canvas-subtle);
+        border: 1px solid var(--color-border-default);
+        border-radius: 6px;
+        padding: 6px;
+      }
+      .subnav-item .octicon.octicon-settings {
+        margin-right: 0;
+      }
+      .subnav-item .octicon.octicon-clock {
+        margin-right: 0;
+        color: var(--color-fg-default) !important;
+      }
+      @media only screen and (max-width: 600px) {
+        .subnav-item,
+        .form-control {
+          border-radius: 0 !important;
+        }
+        .subnav-item {
+          border: none;
+        }
+        .subnav-search-input {
+          border-left: 0;
+          border-right: 0;
+        }
+      }
+      .header-view-status-container {
+        float: right;
+      }
+      .header-view {
+        padding: 12px 8px 0;
+      }
+      .header-view div {
+        flex-shrink: 0;
+        flex-wrap: wrap;
+      }
+      .header-superheader {
+        color: var(--color-fg-muted);
+      }
+      .header-title {
+        flex: none;
+        font-weight: 400;
+        font-size: 32px;
+        line-height: 1.25;
+      }
+      @media only screen and (max-width: 600px) {
+        .header-view {
+          padding: 0;
+        }
+        .header-view div {
+          flex-shrink: 1;
+        }
+        .header-view-status-container {
+          float: none;
+          margin: 0 0 10px !important;
+          overflow: hidden;
+        }
+        .header-view-status-container .subnav-search-input {
+          border-left: none;
+          border-right: none;
+        }
+        .header-title,
+        .header-superheader {
+          margin: 0 8px;
+        }
+      }
+      .copy-icon {
+        flex: none;
+        height: 24px;
+        width: 24px;
+        border: none;
+        outline: none;
+        color: var(--color-fg-muted);
+        background: transparent;
+        padding: 4px;
+        cursor: pointer;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        border-radius: 4px;
+      }
+      .copy-icon svg {
+        margin: 0;
+      }
+      .copy-icon:not(:disabled):hover {
+        background-color: var(--color-border-default);
+      }
+      .copy-button-container {
+        visibility: hidden;
+        display: inline-flex;
+        margin-left: 8px;
+        vertical-align: bottom;
+      }
+      .copy-value-container:hover .copy-button-container {
+        visibility: visible;
+      }
+      .attachment-body {
+        white-space: pre-wrap;
+        background-color: var(--color-canvas-subtle);
+        margin-left: 24px;
+        line-height: normal;
+        padding: 8px;
+        font-family: monospace;
+        position: relative;
+      }
+      .attachment-body .copy-icon {
+        position: absolute;
+        right: 5px;
+        top: 5px;
+      }
+      .link-badge {
+        flex: none;
+        background-color: transparent;
+        border-color: transparent;
+        -webkit-user-select: none;
+        user-select: none;
+      }
+      .link-badge-dim span {
+        color: var(--color-fg-muted);
+      }
+      .link-badge:hover {
+        cursor: pointer;
+      }
+      .link-badge svg {
+        fill: var(--color-fg-default);
+      }
+      .link-badge-dim svg {
+        fill: var(--color-fg-muted);
+      }
+      .link-badge-dim:hover svg {
+        fill: var(--color-fg-muted);
+      }
+      .fullwidth-link {
+        width: 100%;
+        text-align: left;
+      }
+      .fullwidth-link:hover {
+        background-color: var(--color-canvas-subtle);
+      }
+      .trace-link {
+        margin-right: 3px;
+      }
+      .trace-link-separator {
+        color: var(--color-fg-muted);
+        -webkit-user-select: none;
+        user-select: none;
+      }
+      .expandable-summary {
+        cursor: pointer;
+        list-style: none;
+        white-space: nowrap;
+        padding-left: 4px;
+      }
+      .label {
+        display: inline-block;
+        padding: 0 8px;
+        font-size: 12px;
+        font-weight: 500;
+        line-height: 18px;
+        border: 1px solid transparent;
+        border-radius: 2em;
+        background-color: var(--color-scale-gray-4);
+        color: #fff;
+        margin: 0 10px;
+        flex: none;
+        font-weight: 600;
+        cursor: pointer;
+      }
+      .label-anchor {
+        text-decoration: none;
+        color: var(--color-fg-default);
+      }
+      :root.light-mode .label-color-0 {
+        background-color: var(--color-scale-blue-0);
+        color: var(--color-scale-blue-6);
+        border: 1px solid var(--color-scale-blue-4);
+      }
+      :root.light-mode .label-color-1 {
+        background-color: var(--color-scale-yellow-0);
+        color: var(--color-scale-yellow-6);
+        border: 1px solid var(--color-scale-yellow-4);
+      }
+      :root.light-mode .label-color-2 {
+        background-color: var(--color-scale-purple-0);
+        color: var(--color-scale-purple-6);
+        border: 1px solid var(--color-scale-purple-4);
+      }
+      :root.light-mode .label-color-3 {
+        background-color: var(--color-scale-pink-0);
+        color: var(--color-scale-pink-6);
+        border: 1px solid var(--color-scale-pink-4);
+      }
+      :root.light-mode .label-color-4 {
+        background-color: var(--color-scale-coral-0);
+        color: var(--color-scale-coral-6);
+        border: 1px solid var(--color-scale-coral-4);
+      }
+      :root.light-mode .label-color-5 {
+        background-color: var(--color-scale-orange-0);
+        color: var(--color-scale-orange-6);
+        border: 1px solid var(--color-scale-orange-4);
+      }
+      :root.dark-mode .label-color-0 {
+        background-color: var(--color-scale-blue-9);
+        color: var(--color-scale-blue-2);
+        border: 1px solid var(--color-scale-blue-4);
+      }
+      :root.dark-mode .label-color-1 {
+        background-color: var(--color-scale-yellow-9);
+        color: var(--color-scale-yellow-2);
+        border: 1px solid var(--color-scale-yellow-4);
+      }
+      :root.dark-mode .label-color-2 {
+        background-color: var(--color-scale-purple-9);
+        color: var(--color-scale-purple-2);
+        border: 1px solid var(--color-scale-purple-4);
+      }
+      :root.dark-mode .label-color-3 {
+        background-color: var(--color-scale-pink-9);
+        color: var(--color-scale-pink-2);
+        border: 1px solid var(--color-scale-pink-4);
+      }
+      :root.dark-mode .label-color-4 {
+        background-color: var(--color-scale-coral-9);
+        color: var(--color-scale-coral-2);
+        border: 1px solid var(--color-scale-coral-4);
+      }
+      :root.dark-mode .label-color-5 {
+        background-color: var(--color-scale-orange-9);
+        color: var(--color-scale-orange-2);
+        border: 1px solid var(--color-scale-orange-4);
+      }
+      .label-row .label {
+        margin: 0;
+      }
+      .label-row .label:not(:first-child) {
+        margin-left: 6px;
+      }
+      html,
+      body {
+        width: 100%;
+        height: 100%;
+        padding: 0;
+        margin: 0;
+        overscroll-behavior-x: none;
+      }
+      body {
+        overflow: auto;
+        max-width: 1024px;
+        margin: 0 auto;
+        width: 100%;
+      }
+      .test-file-test:not(:first-child) {
+        border-top: 1px solid var(--color-border-default);
+      }
+      @media only screen and (max-width: 600px) {
+        .htmlreport {
+          padding: 0 !important;
+        }
+      }
+      .tabbed-pane {
+        display: flex;
+        flex: auto;
+        overflow: hidden;
+      }
+      .tabbed-pane-tab-strip {
+        display: flex;
+        align-items: center;
+        padding-right: 10px;
+        flex: none;
+        width: 100%;
+        z-index: 2;
+        font-size: 14px;
+        line-height: 32px;
+        color: var(--color-fg-default);
+        height: 48px;
+        min-width: 70px;
+        box-shadow: inset 0 -1px 0 var(--color-border-muted) !important;
+      }
+      .tabbed-pane-tab-strip:focus {
+        outline: none;
+      }
+      .tabbed-pane-tab-element {
+        padding: 4px 8px 0;
+        margin-right: 4px;
+        cursor: pointer;
+        display: flex;
+        flex: none;
+        align-items: center;
+        justify-content: center;
+        -webkit-user-select: none;
+        user-select: none;
+        border-bottom: 2px solid transparent;
+        outline: none;
+        height: 100%;
+      }
+      .tabbed-pane-tab-label {
+        max-width: 250px;
+        white-space: pre;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        display: inline-block;
+        height: 30px;
+        padding: 0 8px;
+        border-radius: 6px;
+      }
+      .tabbed-pane-tab-label:hover {
+        background-color: var(--color-control-transparent-bg-hover);
+      }
+      .tabbed-pane-tab-element.selected {
+        border-bottom-color: #666;
+        -webkit-text-stroke: 0.5px currentColor;
+      }
+      .chip-header {
+        border: 1px solid var(--color-border-default);
+        border-top-left-radius: 6px;
+        border-top-right-radius: 6px;
+        background-color: var(--color-canvas-subtle);
+        padding: 0 8px;
+        border-bottom: none;
+        margin-top: 12px;
+        font-weight: 600;
+        line-height: 38px;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        -webkit-user-select: none;
+        user-select: none;
+      }
+      .chip-header-allow-selection {
+        -webkit-user-select: text;
+        user-select: text;
+      }
+      .chip-header.expanded-false {
+        border: 1px solid var(--color-border-default);
+        border-radius: 6px;
+      }
+      .chip-header.expanded-false,
+      .chip-header.expanded-true {
+        cursor: pointer;
+      }
+      .chip-body {
+        border: 1px solid var(--color-border-default);
+        border-bottom-left-radius: 6px;
+        border-bottom-right-radius: 6px;
+        padding: 16px;
+        margin-bottom: 12px;
+        overflow: hidden;
+      }
+      .chip-body-no-insets {
+        padding: 0;
+      }
+      .chip-footer {
+        border-top: 1px solid var(--color-border-default);
+      }
+      @media only screen and (max-width: 600px) {
+        .chip-header {
+          border-radius: 0;
+          border-right: none;
+          border-left: none;
+        }
+        .chip-body {
+          border-radius: 0;
+          border-right: none;
+          border-left: none;
+          padding: 8px;
+        }
+        .chip-body-no-insets {
+          padding: 0;
+        }
+      }
+      .test-case-column {
+        border-radius: 6px;
+        margin-bottom: 24px;
+      }
+      .test-case-column .tab-element.selected {
+        font-weight: 600;
+        border-bottom-color: var(--color-primer-border-active);
+      }
+      .test-case-column .tab-element {
+        border: none;
+        color: var(--color-fg-default);
+        border-bottom: 2px solid transparent;
+      }
+      .test-case-column .tab-element:hover {
+        color: var(--color-fg-default);
+      }
+      .test-case-location,
+      .test-case-duration {
+        flex: none;
+        align-items: center;
+        padding: 0 8px 8px;
+      }
+      .selected .test-case-run-duration {
+        -webkit-text-stroke: 0;
+      }
+      .test-case-run-duration {
+        color: var(--color-fg-muted);
+        padding-left: 8px;
+      }
+      .header-view .test-case-path {
+        flex: none;
+        flex-shrink: 1;
+        align-items: center;
+        padding-right: 8px;
+      }
+      .test-case-annotation {
+        flex: none;
+        align-items: center;
+        padding: 0 8px;
+        line-height: 24px;
+        white-space: pre-wrap;
+      }
+      @media only screen and (max-width: 600px) {
+        .test-case-column {
+          border-radius: 0 !important;
+          margin: 0 !important;
+        }
+      }
+      .tree-item {
+        text-overflow: ellipsis;
+        overflow: hidden;
+        white-space: nowrap;
+        line-height: 38px;
+      }
+      .tree-item-title {
+        cursor: pointer;
+      }
+      .tree-item-body {
+        min-height: 18px;
+      }
+      .yellow-flash {
+        animation: yellowflash-bg 2s;
+      }
+      @keyframes yellowflash-bg {
+        0% {
+          background: var(--color-attention-subtle);
+        }
+        to {
+          background: transparent;
+        }
+      }
+      :root {
+        --vscode-font-family: system-ui, 'Ubuntu', 'Droid Sans', sans-serif;
+        --vscode-font-weight: normal;
+        --vscode-font-size: 13px;
+        --vscode-editor-font-family: 'Droid Sans Mono', 'monospace', monospace;
+        --vscode-editor-font-weight: normal;
+        --vscode-editor-font-size: 14px;
+        --vscode-foreground: #616161;
+        --vscode-disabledForeground: rgba(97, 97, 97, 0.5);
+        --vscode-errorForeground: #a1260d;
+        --vscode-descriptionForeground: #717171;
+        --vscode-icon-foreground: #424242;
+        --vscode-focusBorder: #0090f1;
+        --vscode-textSeparator-foreground: rgba(0, 0, 0, 0.18);
+        --vscode-textLink-foreground: #006ab1;
+        --vscode-textLink-activeForeground: #006ab1;
+        --vscode-textPreformat-foreground: #a31515;
+        --vscode-textBlockQuote-background: rgba(127, 127, 127, 0.1);
+        --vscode-textBlockQuote-border: rgba(0, 122, 204, 0.5);
+        --vscode-textCodeBlock-background: rgba(220, 220, 220, 0.4);
+        --vscode-widget-shadow: rgba(0, 0, 0, 0.16);
+        --vscode-input-background: #ffffff;
+        --vscode-input-foreground: #616161;
+        --vscode-inputOption-activeBorder: #007acc;
+        --vscode-inputOption-hoverBackground: rgba(184, 184, 184, 0.31);
+        --vscode-inputOption-activeBackground: rgba(0, 144, 241, 0.2);
+        --vscode-inputOption-activeForeground: #000000;
+        --vscode-input-placeholderForeground: #767676;
+        --vscode-inputValidation-infoBackground: #d6ecf2;
+        --vscode-inputValidation-infoBorder: #007acc;
+        --vscode-inputValidation-warningBackground: #f6f5d2;
+        --vscode-inputValidation-warningBorder: #b89500;
+        --vscode-inputValidation-errorBackground: #f2dede;
+        --vscode-inputValidation-errorBorder: #be1100;
+        --vscode-dropdown-background: #ffffff;
+        --vscode-dropdown-border: #cecece;
+        --vscode-checkbox-background: #ffffff;
+        --vscode-checkbox-border: #cecece;
+        --vscode-button-foreground: #ffffff;
+        --vscode-button-separator: rgba(255, 255, 255, 0.4);
+        --vscode-button-background: #007acc;
+        --vscode-button-hoverBackground: #0062a3;
+        --vscode-button-secondaryForeground: #ffffff;
+        --vscode-button-secondaryBackground: #5f6a79;
+        --vscode-button-secondaryHoverBackground: #4c5561;
+        --vscode-badge-background: #c4c4c4;
+        --vscode-badge-foreground: #333333;
+        --vscode-scrollbar-shadow: #dddddd;
+        --vscode-scrollbarSlider-background: rgba(100, 100, 100, 0.4);
+        --vscode-scrollbarSlider-hoverBackground: rgba(100, 100, 100, 0.7);
+        --vscode-scrollbarSlider-activeBackground: rgba(0, 0, 0, 0.6);
+        --vscode-progressBar-background: #0e70c0;
+        --vscode-editorError-foreground: #e51400;
+        --vscode-editorWarning-foreground: #bf8803;
+        --vscode-editorInfo-foreground: #1a85ff;
+        --vscode-editorHint-foreground: #6c6c6c;
+        --vscode-sash-hoverBorder: #0090f1;
+        --vscode-editor-background: #ffffff;
+        --vscode-editor-foreground: #000000;
+        --vscode-editorStickyScroll-background: #ffffff;
+        --vscode-editorStickyScrollHover-background: #f0f0f0;
+        --vscode-editorWidget-background: #f3f3f3;
+        --vscode-editorWidget-foreground: #616161;
+        --vscode-editorWidget-border: #c8c8c8;
+        --vscode-quickInput-background: #f3f3f3;
+        --vscode-quickInput-foreground: #616161;
+        --vscode-quickInputTitle-background: rgba(0, 0, 0, 0.06);
+        --vscode-pickerGroup-foreground: #0066bf;
+        --vscode-pickerGroup-border: #cccedb;
+        --vscode-keybindingLabel-background: rgba(221, 221, 221, 0.4);
+        --vscode-keybindingLabel-foreground: #555555;
+        --vscode-keybindingLabel-border: rgba(204, 204, 204, 0.4);
+        --vscode-keybindingLabel-bottomBorder: rgba(187, 187, 187, 0.4);
+        --vscode-editor-selectionBackground: #add6ff;
+        --vscode-editor-inactiveSelectionBackground: #e5ebf1;
+        --vscode-editor-selectionHighlightBackground: rgba(173, 214, 255, 0.5);
+        --vscode-editor-findMatchBackground: #a8ac94;
+        --vscode-editor-findMatchHighlightBackground: rgba(234, 92, 0, 0.33);
+        --vscode-editor-findRangeHighlightBackground: rgba(180, 180, 180, 0.3);
+        --vscode-searchEditor-findMatchBackground: rgba(234, 92, 0, 0.22);
+        --vscode-editor-hoverHighlightBackground: rgba(173, 214, 255, 0.15);
+        --vscode-editorHoverWidget-background: #f3f3f3;
+        --vscode-editorHoverWidget-foreground: #616161;
+        --vscode-editorHoverWidget-border: #c8c8c8;
+        --vscode-editorHoverWidget-statusBarBackground: #e7e7e7;
+        --vscode-editorLink-activeForeground: #0000ff;
+        --vscode-editorInlayHint-foreground: rgba(51, 51, 51, 0.8);
+        --vscode-editorInlayHint-background: rgba(196, 196, 196, 0.3);
+        --vscode-editorInlayHint-typeForeground: rgba(51, 51, 51, 0.8);
+        --vscode-editorInlayHint-typeBackground: rgba(196, 196, 196, 0.3);
+        --vscode-editorInlayHint-parameterForeground: rgba(51, 51, 51, 0.8);
+        --vscode-editorInlayHint-parameterBackground: rgba(196, 196, 196, 0.3);
+        --vscode-editorLightBulb-foreground: #ddb100;
+        --vscode-editorLightBulbAutoFix-foreground: #007acc;
+        --vscode-diffEditor-insertedTextBackground: rgba(156, 204, 44, 0.4);
+        --vscode-diffEditor-removedTextBackground: rgba(255, 0, 0, 0.3);
+        --vscode-diffEditor-insertedLineBackground: rgba(155, 185, 85, 0.2);
+        --vscode-diffEditor-removedLineBackground: rgba(255, 0, 0, 0.2);
+        --vscode-diffEditor-diagonalFill: rgba(34, 34, 34, 0.2);
+        --vscode-list-focusOutline: #0090f1;
+        --vscode-list-focusAndSelectionOutline: #90c2f9;
+        --vscode-list-activeSelectionBackground: #0060c0;
+        --vscode-list-activeSelectionForeground: #ffffff;
+        --vscode-list-activeSelectionIconForeground: #ffffff;
+        --vscode-list-inactiveSelectionBackground: #e4e6f1;
+        --vscode-list-hoverBackground: #e8e8e8;
+        --vscode-list-dropBackground: #d6ebff;
+        --vscode-list-highlightForeground: #0066bf;
+        --vscode-list-focusHighlightForeground: #bbe7ff;
+        --vscode-list-invalidItemForeground: #b89500;
+        --vscode-list-errorForeground: #b01011;
+        --vscode-list-warningForeground: #855f00;
+        --vscode-listFilterWidget-background: #f3f3f3;
+        --vscode-listFilterWidget-outline: rgba(0, 0, 0, 0);
+        --vscode-listFilterWidget-noMatchesOutline: #be1100;
+        --vscode-listFilterWidget-shadow: rgba(0, 0, 0, 0.16);
+        --vscode-list-filterMatchBackground: rgba(234, 92, 0, 0.33);
+        --vscode-tree-indentGuidesStroke: #a9a9a9;
+        --vscode-tree-tableColumnsBorder: rgba(97, 97, 97, 0.13);
+        --vscode-tree-tableOddRowsBackground: rgba(97, 97, 97, 0.04);
+        --vscode-list-deemphasizedForeground: #8e8e90;
+        --vscode-quickInputList-focusForeground: #ffffff;
+        --vscode-quickInputList-focusIconForeground: #ffffff;
+        --vscode-quickInputList-focusBackground: #0060c0;
+        --vscode-menu-foreground: #616161;
+        --vscode-menu-background: #ffffff;
+        --vscode-menu-selectionForeground: #ffffff;
+        --vscode-menu-selectionBackground: #0060c0;
+        --vscode-menu-separatorBackground: #d4d4d4;
+        --vscode-toolbar-hoverBackground: rgba(184, 184, 184, 0.31);
+        --vscode-toolbar-activeBackground: rgba(166, 166, 166, 0.31);
+        --vscode-editor-snippetTabstopHighlightBackground: rgba(
+          10,
+          50,
+          100,
+          0.2
+        );
+        --vscode-editor-snippetFinalTabstopHighlightBorder: rgba(
+          10,
+          50,
+          100,
+          0.5
+        );
+        --vscode-breadcrumb-foreground: rgba(97, 97, 97, 0.8);
+        --vscode-breadcrumb-background: #ffffff;
+        --vscode-breadcrumb-focusForeground: #4e4e4e;
+        --vscode-breadcrumb-activeSelectionForeground: #4e4e4e;
+        --vscode-breadcrumbPicker-background: #f3f3f3;
+        --vscode-merge-currentHeaderBackground: rgba(64, 200, 174, 0.5);
+        --vscode-merge-currentContentBackground: rgba(64, 200, 174, 0.2);
+        --vscode-merge-incomingHeaderBackground: rgba(64, 166, 255, 0.5);
+        --vscode-merge-incomingContentBackground: rgba(64, 166, 255, 0.2);
+        --vscode-merge-commonHeaderBackground: rgba(96, 96, 96, 0.4);
+        --vscode-merge-commonContentBackground: rgba(96, 96, 96, 0.16);
+        --vscode-editorOverviewRuler-currentContentForeground: rgba(
+          64,
+          200,
+          174,
+          0.5
+        );
+        --vscode-editorOverviewRuler-incomingContentForeground: rgba(
+          64,
+          166,
+          255,
+          0.5
+        );
+        --vscode-editorOverviewRuler-commonContentForeground: rgba(
+          96,
+          96,
+          96,
+          0.4
+        );
+        --vscode-editorOverviewRuler-findMatchForeground: rgba(
+          209,
+          134,
+          22,
+          0.49
+        );
+        --vscode-editorOverviewRuler-selectionHighlightForeground: rgba(
+          160,
+          160,
+          160,
+          0.8
+        );
+        --vscode-minimap-findMatchHighlight: #d18616;
+        --vscode-minimap-selectionOccurrenceHighlight: #c9c9c9;
+        --vscode-minimap-selectionHighlight: #add6ff;
+        --vscode-minimap-errorHighlight: rgba(255, 18, 18, 0.7);
+        --vscode-minimap-warningHighlight: #bf8803;
+        --vscode-minimap-foregroundOpacity: #000000;
+        --vscode-minimapSlider-background: rgba(100, 100, 100, 0.2);
+        --vscode-minimapSlider-hoverBackground: rgba(100, 100, 100, 0.35);
+        --vscode-minimapSlider-activeBackground: rgba(0, 0, 0, 0.3);
+        --vscode-problemsErrorIcon-foreground: #e51400;
+        --vscode-problemsWarningIcon-foreground: #bf8803;
+        --vscode-problemsInfoIcon-foreground: #1a85ff;
+        --vscode-charts-foreground: #616161;
+        --vscode-charts-lines: rgba(97, 97, 97, 0.5);
+        --vscode-charts-red: #e51400;
+        --vscode-charts-blue: #1a85ff;
+        --vscode-charts-yellow: #bf8803;
+        --vscode-charts-orange: #d18616;
+        --vscode-charts-green: #388a34;
+        --vscode-charts-purple: #652d90;
+        --vscode-editor-lineHighlightBorder: #eeeeee;
+        --vscode-editor-rangeHighlightBackground: rgba(253, 255, 0, 0.2);
+        --vscode-editor-symbolHighlightBackground: rgba(234, 92, 0, 0.33);
+        --vscode-editorCursor-foreground: #000000;
+        --vscode-editorWhitespace-foreground: rgba(51, 51, 51, 0.2);
+        --vscode-editorIndentGuide-background: #d3d3d3;
+        --vscode-editorIndentGuide-activeBackground: #939393;
+        --vscode-editorLineNumber-foreground: #237893;
+        --vscode-editorActiveLineNumber-foreground: #0b216f;
+        --vscode-editorLineNumber-activeForeground: #0b216f;
+        --vscode-editorRuler-foreground: #d3d3d3;
+        --vscode-editorCodeLens-foreground: #919191;
+        --vscode-editorBracketMatch-background: rgba(0, 100, 0, 0.1);
+        --vscode-editorBracketMatch-border: #b9b9b9;
+        --vscode-editorOverviewRuler-border: rgba(127, 127, 127, 0.3);
+        --vscode-editorGutter-background: #ffffff;
+        --vscode-editorUnnecessaryCode-opacity: rgba(0, 0, 0, 0.47);
+        --vscode-editorGhostText-foreground: rgba(0, 0, 0, 0.47);
+        --vscode-editorOverviewRuler-rangeHighlightForeground: rgba(
+          0,
+          122,
+          204,
+          0.6
+        );
+        --vscode-editorOverviewRuler-errorForeground: rgba(255, 18, 18, 0.7);
+        --vscode-editorOverviewRuler-warningForeground: #bf8803;
+        --vscode-editorOverviewRuler-infoForeground: #1a85ff;
+        --vscode-editorBracketHighlight-foreground1: #0431fa;
+        --vscode-editorBracketHighlight-foreground2: #319331;
+        --vscode-editorBracketHighlight-foreground3: #7b3814;
+        --vscode-editorBracketHighlight-foreground4: rgba(0, 0, 0, 0);
+        --vscode-editorBracketHighlight-foreground5: rgba(0, 0, 0, 0);
+        --vscode-editorBracketHighlight-foreground6: rgba(0, 0, 0, 0);
+        --vscode-editorBracketHighlight-unexpectedBracket\.foreground: rgba(
+          255,
+          18,
+          18,
+          0.8
+        );
+        --vscode-editorBracketPairGuide-background1: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-background2: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-background3: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-background4: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-background5: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-background6: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-activeBackground1: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-activeBackground2: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-activeBackground3: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-activeBackground4: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-activeBackground5: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-activeBackground6: rgba(0, 0, 0, 0);
+        --vscode-editorUnicodeHighlight-border: #cea33d;
+        --vscode-editorUnicodeHighlight-background: rgba(206, 163, 61, 0.08);
+        --vscode-symbolIcon-arrayForeground: #616161;
+        --vscode-symbolIcon-booleanForeground: #616161;
+        --vscode-symbolIcon-classForeground: #d67e00;
+        --vscode-symbolIcon-colorForeground: #616161;
+        --vscode-symbolIcon-constantForeground: #616161;
+        --vscode-symbolIcon-constructorForeground: #652d90;
+        --vscode-symbolIcon-enumeratorForeground: #d67e00;
+        --vscode-symbolIcon-enumeratorMemberForeground: #007acc;
+        --vscode-symbolIcon-eventForeground: #d67e00;
+        --vscode-symbolIcon-fieldForeground: #007acc;
+        --vscode-symbolIcon-fileForeground: #616161;
+        --vscode-symbolIcon-folderForeground: #616161;
+        --vscode-symbolIcon-functionForeground: #652d90;
+        --vscode-symbolIcon-interfaceForeground: #007acc;
+        --vscode-symbolIcon-keyForeground: #616161;
+        --vscode-symbolIcon-keywordForeground: #616161;
+        --vscode-symbolIcon-methodForeground: #652d90;
+        --vscode-symbolIcon-moduleForeground: #616161;
+        --vscode-symbolIcon-namespaceForeground: #616161;
+        --vscode-symbolIcon-nullForeground: #616161;
+        --vscode-symbolIcon-numberForeground: #616161;
+        --vscode-symbolIcon-objectForeground: #616161;
+        --vscode-symbolIcon-operatorForeground: #616161;
+        --vscode-symbolIcon-packageForeground: #616161;
+        --vscode-symbolIcon-propertyForeground: #616161;
+        --vscode-symbolIcon-referenceForeground: #616161;
+        --vscode-symbolIcon-snippetForeground: #616161;
+        --vscode-symbolIcon-stringForeground: #616161;
+        --vscode-symbolIcon-structForeground: #616161;
+        --vscode-symbolIcon-textForeground: #616161;
+        --vscode-symbolIcon-typeParameterForeground: #616161;
+        --vscode-symbolIcon-unitForeground: #616161;
+        --vscode-symbolIcon-variableForeground: #007acc;
+        --vscode-editorHoverWidget-highlightForeground: #0066bf;
+        --vscode-editorOverviewRuler-bracketMatchForeground: #a0a0a0;
+        --vscode-editor-foldBackground: rgba(173, 214, 255, 0.3);
+        --vscode-editorGutter-foldingControlForeground: #424242;
+        --vscode-editor-linkedEditingBackground: rgba(255, 0, 0, 0.3);
+        --vscode-editor-wordHighlightBackground: rgba(87, 87, 87, 0.25);
+        --vscode-editor-wordHighlightStrongBackground: rgba(14, 99, 156, 0.25);
+        --vscode-editorOverviewRuler-wordHighlightForeground: rgba(
+          160,
+          160,
+          160,
+          0.8
+        );
+        --vscode-editorOverviewRuler-wordHighlightStrongForeground: rgba(
+          192,
+          160,
+          192,
+          0.8
+        );
+        --vscode-peekViewTitle-background: rgba(26, 133, 255, 0.1);
+        --vscode-peekViewTitleLabel-foreground: #000000;
+        --vscode-peekViewTitleDescription-foreground: #616161;
+        --vscode-peekView-border: #1a85ff;
+        --vscode-peekViewResult-background: #f3f3f3;
+        --vscode-peekViewResult-lineForeground: #646465;
+        --vscode-peekViewResult-fileForeground: #1e1e1e;
+        --vscode-peekViewResult-selectionBackground: rgba(51, 153, 255, 0.2);
+        --vscode-peekViewResult-selectionForeground: #6c6c6c;
+        --vscode-peekViewEditor-background: #f2f8fc;
+        --vscode-peekViewEditorGutter-background: #f2f8fc;
+        --vscode-peekViewResult-matchHighlightBackground: rgba(234, 92, 0, 0.3);
+        --vscode-peekViewEditor-matchHighlightBackground: rgba(
+          245,
+          216,
+          2,
+          0.87
+        );
+        --vscode-editorMarkerNavigationError-background: #e51400;
+        --vscode-editorMarkerNavigationError-headerBackground: rgba(
+          229,
+          20,
+          0,
+          0.1
+        );
+        --vscode-editorMarkerNavigationWarning-background: #bf8803;
+        --vscode-editorMarkerNavigationWarning-headerBackground: rgba(
+          191,
+          136,
+          3,
+          0.1
+        );
+        --vscode-editorMarkerNavigationInfo-background: #1a85ff;
+        --vscode-editorMarkerNavigationInfo-headerBackground: rgba(
+          26,
+          133,
+          255,
+          0.1
+        );
+        --vscode-editorMarkerNavigation-background: #ffffff;
+        --vscode-editorSuggestWidget-background: #f3f3f3;
+        --vscode-editorSuggestWidget-border: #c8c8c8;
+        --vscode-editorSuggestWidget-foreground: #000000;
+        --vscode-editorSuggestWidget-selectedForeground: #ffffff;
+        --vscode-editorSuggestWidget-selectedIconForeground: #ffffff;
+        --vscode-editorSuggestWidget-selectedBackground: #0060c0;
+        --vscode-editorSuggestWidget-highlightForeground: #0066bf;
+        --vscode-editorSuggestWidget-focusHighlightForeground: #bbe7ff;
+        --vscode-editorSuggestWidgetStatus-foreground: rgba(0, 0, 0, 0.5);
+        --vscode-tab-activeBackground: #ffffff;
+        --vscode-tab-unfocusedActiveBackground: #ffffff;
+        --vscode-tab-inactiveBackground: #ececec;
+        --vscode-tab-unfocusedInactiveBackground: #ececec;
+        --vscode-tab-activeForeground: #333333;
+        --vscode-tab-inactiveForeground: rgba(51, 51, 51, 0.7);
+        --vscode-tab-unfocusedActiveForeground: rgba(51, 51, 51, 0.7);
+        --vscode-tab-unfocusedInactiveForeground: rgba(51, 51, 51, 0.35);
+        --vscode-tab-border: #f3f3f3;
+        --vscode-tab-lastPinnedBorder: rgba(97, 97, 97, 0.19);
+        --vscode-tab-activeModifiedBorder: #33aaee;
+        --vscode-tab-inactiveModifiedBorder: rgba(51, 170, 238, 0.5);
+        --vscode-tab-unfocusedActiveModifiedBorder: rgba(51, 170, 238, 0.7);
+        --vscode-tab-unfocusedInactiveModifiedBorder: rgba(51, 170, 238, 0.25);
+        --vscode-editorPane-background: #ffffff;
+        --vscode-editorGroupHeader-tabsBackground: #f3f3f3;
+        --vscode-editorGroupHeader-noTabsBackground: #ffffff;
+        --vscode-editorGroup-border: #e7e7e7;
+        --vscode-editorGroup-dropBackground: rgba(38, 119, 203, 0.18);
+        --vscode-editorGroup-dropIntoPromptForeground: #616161;
+        --vscode-editorGroup-dropIntoPromptBackground: #f3f3f3;
+        --vscode-sideBySideEditor-horizontalBorder: #e7e7e7;
+        --vscode-sideBySideEditor-verticalBorder: #e7e7e7;
+        --vscode-panel-background: #ffffff;
+        --vscode-panel-border: rgba(128, 128, 128, 0.35);
+        --vscode-panelTitle-activeForeground: #424242;
+        --vscode-panelTitle-inactiveForeground: rgba(66, 66, 66, 0.75);
+        --vscode-panelTitle-activeBorder: #424242;
+        --vscode-panelInput-border: #dddddd;
+        --vscode-panel-dropBorder: #424242;
+        --vscode-panelSection-dropBackground: rgba(38, 119, 203, 0.18);
+        --vscode-panelSectionHeader-background: rgba(128, 128, 128, 0.2);
+        --vscode-panelSection-border: rgba(128, 128, 128, 0.35);
+        --vscode-banner-background: #004386;
+        --vscode-banner-foreground: #ffffff;
+        --vscode-banner-iconForeground: #1a85ff;
+        --vscode-statusBar-foreground: #ffffff;
+        --vscode-statusBar-noFolderForeground: #ffffff;
+        --vscode-statusBar-background: #007acc;
+        --vscode-statusBar-noFolderBackground: #68217a;
+        --vscode-statusBar-focusBorder: #ffffff;
+        --vscode-statusBarItem-activeBackground: rgba(255, 255, 255, 0.18);
+        --vscode-statusBarItem-focusBorder: #ffffff;
+        --vscode-statusBarItem-hoverBackground: rgba(255, 255, 255, 0.12);
+        --vscode-statusBarItem-compactHoverBackground: rgba(255, 255, 255, 0.2);
+        --vscode-statusBarItem-prominentForeground: #ffffff;
+        --vscode-statusBarItem-prominentBackground: rgba(0, 0, 0, 0.5);
+        --vscode-statusBarItem-prominentHoverBackground: rgba(0, 0, 0, 0.3);
+        --vscode-statusBarItem-errorBackground: #c72e0f;
+        --vscode-statusBarItem-errorForeground: #ffffff;
+        --vscode-statusBarItem-warningBackground: #725102;
+        --vscode-statusBarItem-warningForeground: #ffffff;
+        --vscode-activityBar-background: #2c2c2c;
+        --vscode-activityBar-foreground: #ffffff;
+        --vscode-activityBar-inactiveForeground: rgba(255, 255, 255, 0.4);
+        --vscode-activityBar-activeBorder: #ffffff;
+        --vscode-activityBar-dropBorder: #ffffff;
+        --vscode-activityBarBadge-background: #007acc;
+        --vscode-activityBarBadge-foreground: #ffffff;
+        --vscode-statusBarItem-remoteBackground: #16825d;
+        --vscode-statusBarItem-remoteForeground: #ffffff;
+        --vscode-extensionBadge-remoteBackground: #007acc;
+        --vscode-extensionBadge-remoteForeground: #ffffff;
+        --vscode-sideBar-background: #f3f3f3;
+        --vscode-sideBarTitle-foreground: #6f6f6f;
+        --vscode-sideBar-dropBackground: rgba(38, 119, 203, 0.18);
+        --vscode-sideBarSectionHeader-background: rgba(0, 0, 0, 0);
+        --vscode-sideBarSectionHeader-border: rgba(97, 97, 97, 0.19);
+        --vscode-titleBar-activeForeground: #333333;
+        --vscode-titleBar-inactiveForeground: rgba(51, 51, 51, 0.6);
+        --vscode-titleBar-activeBackground: #dddddd;
+        --vscode-titleBar-inactiveBackground: rgba(221, 221, 221, 0.6);
+        --vscode-menubar-selectionForeground: #333333;
+        --vscode-menubar-selectionBackground: rgba(184, 184, 184, 0.31);
+        --vscode-notifications-foreground: #616161;
+        --vscode-notifications-background: #f3f3f3;
+        --vscode-notificationLink-foreground: #006ab1;
+        --vscode-notificationCenterHeader-background: #e7e7e7;
+        --vscode-notifications-border: #e7e7e7;
+        --vscode-notificationsErrorIcon-foreground: #e51400;
+        --vscode-notificationsWarningIcon-foreground: #bf8803;
+        --vscode-notificationsInfoIcon-foreground: #1a85ff;
+        --vscode-commandCenter-foreground: #333333;
+        --vscode-commandCenter-activeForeground: #333333;
+        --vscode-commandCenter-activeBackground: rgba(184, 184, 184, 0.31);
+        --vscode-commandCenter-border: rgba(128, 128, 128, 0.35);
+        --vscode-editorCommentsWidget-resolvedBorder: rgba(97, 97, 97, 0.5);
+        --vscode-editorCommentsWidget-unresolvedBorder: #1a85ff;
+        --vscode-editorCommentsWidget-rangeBackground: rgba(26, 133, 255, 0.1);
+        --vscode-editorCommentsWidget-rangeBorder: rgba(26, 133, 255, 0.4);
+        --vscode-editorCommentsWidget-rangeActiveBackground: rgba(
+          26,
+          133,
+          255,
+          0.1
+        );
+        --vscode-editorCommentsWidget-rangeActiveBorder: rgba(
+          26,
+          133,
+          255,
+          0.4
+        );
+        --vscode-editorGutter-commentRangeForeground: #d5d8e9;
+        --vscode-debugToolBar-background: #f3f3f3;
+        --vscode-debugIcon-startForeground: #388a34;
+        --vscode-editor-stackFrameHighlightBackground: rgba(
+          255,
+          255,
+          102,
+          0.45
+        );
+        --vscode-editor-focusedStackFrameHighlightBackground: rgba(
+          206,
+          231,
+          206,
+          0.45
+        );
+        --vscode-mergeEditor-change\.background: rgba(155, 185, 85, 0.2);
+        --vscode-mergeEditor-change\.word\.background: rgba(156, 204, 44, 0.4);
+        --vscode-mergeEditor-conflict\.unhandledUnfocused\.border: rgba(
+          255,
+          166,
+          0,
+          0.48
+        );
+        --vscode-mergeEditor-conflict\.unhandledFocused\.border: #ffa600;
+        --vscode-mergeEditor-conflict\.handledUnfocused\.border: rgba(
+          134,
+          134,
+          134,
+          0.29
+        );
+        --vscode-mergeEditor-conflict\.handledFocused\.border: rgba(
+          193,
+          193,
+          193,
+          0.8
+        );
+        --vscode-mergeEditor-conflict\.handled\.minimapOverViewRuler: rgba(
+          173,
+          172,
+          168,
+          0.93
+        );
+        --vscode-mergeEditor-conflict\.unhandled\.minimapOverViewRuler: #fcba03;
+        --vscode-mergeEditor-conflictingLines\.background: rgba(
+          255,
+          234,
+          0,
+          0.28
+        );
+        --vscode-settings-headerForeground: #444444;
+        --vscode-settings-modifiedItemIndicator: #66afe0;
+        --vscode-settings-headerBorder: rgba(128, 128, 128, 0.35);
+        --vscode-settings-sashBorder: rgba(128, 128, 128, 0.35);
+        --vscode-settings-dropdownBackground: #ffffff;
+        --vscode-settings-dropdownBorder: #cecece;
+        --vscode-settings-dropdownListBorder: #c8c8c8;
+        --vscode-settings-checkboxBackground: #ffffff;
+        --vscode-settings-checkboxBorder: #cecece;
+        --vscode-settings-textInputBackground: #ffffff;
+        --vscode-settings-textInputForeground: #616161;
+        --vscode-settings-textInputBorder: #cecece;
+        --vscode-settings-numberInputBackground: #ffffff;
+        --vscode-settings-numberInputForeground: #616161;
+        --vscode-settings-numberInputBorder: #cecece;
+        --vscode-settings-focusedRowBackground: rgba(232, 232, 232, 0.6);
+        --vscode-settings-rowHoverBackground: rgba(232, 232, 232, 0.3);
+        --vscode-settings-focusedRowBorder: rgba(0, 0, 0, 0.12);
+        --vscode-terminal-foreground: #333333;
+        --vscode-terminal-selectionBackground: #add6ff;
+        --vscode-terminal-inactiveSelectionBackground: #e5ebf1;
+        --vscode-terminalCommandDecoration-defaultBackground: rgba(
+          0,
+          0,
+          0,
+          0.25
+        );
+        --vscode-terminalCommandDecoration-successBackground: #2090d3;
+        --vscode-terminalCommandDecoration-errorBackground: #e51400;
+        --vscode-terminalOverviewRuler-cursorForeground: rgba(
+          160,
+          160,
+          160,
+          0.8
+        );
+        --vscode-terminal-border: rgba(128, 128, 128, 0.35);
+        --vscode-terminal-findMatchBackground: #a8ac94;
+        --vscode-terminal-findMatchHighlightBackground: rgba(234, 92, 0, 0.33);
+        --vscode-terminalOverviewRuler-findMatchForeground: rgba(
+          209,
+          134,
+          22,
+          0.49
+        );
+        --vscode-terminal-dropBackground: rgba(38, 119, 203, 0.18);
+        --vscode-testing-iconFailed: #f14c4c;
+        --vscode-testing-iconErrored: #f14c4c;
+        --vscode-testing-iconPassed: #73c991;
+        --vscode-testing-runAction: #73c991;
+        --vscode-testing-iconQueued: #cca700;
+        --vscode-testing-iconUnset: #848484;
+        --vscode-testing-iconSkipped: #848484;
+        --vscode-testing-peekBorder: #e51400;
+        --vscode-testing-peekHeaderBackground: rgba(229, 20, 0, 0.1);
+        --vscode-testing-message\.error\.decorationForeground: #e51400;
+        --vscode-testing-message\.error\.lineBackground: rgba(255, 0, 0, 0.2);
+        --vscode-testing-message\.info\.decorationForeground: rgba(
+          0,
+          0,
+          0,
+          0.5
+        );
+        --vscode-welcomePage-tileBackground: #f3f3f3;
+        --vscode-welcomePage-tileHoverBackground: #dbdbdb;
+        --vscode-welcomePage-tileShadow: rgba(0, 0, 0, 0.16);
+        --vscode-welcomePage-progress\.background: #ffffff;
+        --vscode-welcomePage-progress\.foreground: #006ab1;
+        --vscode-debugExceptionWidget-border: #a31515;
+        --vscode-debugExceptionWidget-background: #f1dfde;
+        --vscode-ports-iconRunningProcessForeground: #369432;
+        --vscode-statusBar-debuggingBackground: #cc6633;
+        --vscode-statusBar-debuggingForeground: #ffffff;
+        --vscode-editor-inlineValuesForeground: rgba(0, 0, 0, 0.5);
+        --vscode-editor-inlineValuesBackground: rgba(255, 200, 0, 0.2);
+        --vscode-editorGutter-modifiedBackground: #2090d3;
+        --vscode-editorGutter-addedBackground: #48985d;
+        --vscode-editorGutter-deletedBackground: #e51400;
+        --vscode-minimapGutter-modifiedBackground: #2090d3;
+        --vscode-minimapGutter-addedBackground: #48985d;
+        --vscode-minimapGutter-deletedBackground: #e51400;
+        --vscode-editorOverviewRuler-modifiedForeground: rgba(
+          32,
+          144,
+          211,
+          0.6
+        );
+        --vscode-editorOverviewRuler-addedForeground: rgba(72, 152, 93, 0.6);
+        --vscode-editorOverviewRuler-deletedForeground: rgba(229, 20, 0, 0.6);
+        --vscode-debugIcon-breakpointForeground: #e51400;
+        --vscode-debugIcon-breakpointDisabledForeground: #848484;
+        --vscode-debugIcon-breakpointUnverifiedForeground: #848484;
+        --vscode-debugIcon-breakpointCurrentStackframeForeground: #be8700;
+        --vscode-debugIcon-breakpointStackframeForeground: #89d185;
+        --vscode-notebook-cellBorderColor: #e8e8e8;
+        --vscode-notebook-focusedEditorBorder: #0090f1;
+        --vscode-notebookStatusSuccessIcon-foreground: #388a34;
+        --vscode-notebookStatusErrorIcon-foreground: #a1260d;
+        --vscode-notebookStatusRunningIcon-foreground: #616161;
+        --vscode-notebook-cellToolbarSeparator: rgba(128, 128, 128, 0.35);
+        --vscode-notebook-selectedCellBackground: rgba(200, 221, 241, 0.31);
+        --vscode-notebook-selectedCellBorder: #e8e8e8;
+        --vscode-notebook-focusedCellBorder: #0090f1;
+        --vscode-notebook-inactiveFocusedCellBorder: #e8e8e8;
+        --vscode-notebook-cellStatusBarItemHoverBackground: rgba(0, 0, 0, 0.08);
+        --vscode-notebook-cellInsertionIndicator: #0090f1;
+        --vscode-notebookScrollbarSlider-background: rgba(100, 100, 100, 0.4);
+        --vscode-notebookScrollbarSlider-hoverBackground: rgba(
+          100,
+          100,
+          100,
+          0.7
+        );
+        --vscode-notebookScrollbarSlider-activeBackground: rgba(0, 0, 0, 0.6);
+        --vscode-notebook-symbolHighlightBackground: rgba(253, 255, 0, 0.2);
+        --vscode-notebook-cellEditorBackground: #f3f3f3;
+        --vscode-notebook-editorBackground: #ffffff;
+        --vscode-keybindingTable-headerBackground: rgba(97, 97, 97, 0.04);
+        --vscode-keybindingTable-rowsBackground: rgba(97, 97, 97, 0.04);
+        --vscode-scm-providerBorder: #c8c8c8;
+        --vscode-searchEditor-textInputBorder: #cecece;
+        --vscode-debugTokenExpression-name: #9b46b0;
+        --vscode-debugTokenExpression-value: rgba(108, 108, 108, 0.8);
+        --vscode-debugTokenExpression-string: #a31515;
+        --vscode-debugTokenExpression-boolean: #0000ff;
+        --vscode-debugTokenExpression-number: #098658;
+        --vscode-debugTokenExpression-error: #e51400;
+        --vscode-debugView-exceptionLabelForeground: #ffffff;
+        --vscode-debugView-exceptionLabelBackground: #a31515;
+        --vscode-debugView-stateLabelForeground: #616161;
+        --vscode-debugView-stateLabelBackground: rgba(136, 136, 136, 0.27);
+        --vscode-debugView-valueChangedHighlight: #569cd6;
+        --vscode-debugConsole-infoForeground: #1a85ff;
+        --vscode-debugConsole-warningForeground: #bf8803;
+        --vscode-debugConsole-errorForeground: #a1260d;
+        --vscode-debugConsole-sourceForeground: #616161;
+        --vscode-debugConsoleInputIcon-foreground: #616161;
+        --vscode-debugIcon-pauseForeground: #007acc;
+        --vscode-debugIcon-stopForeground: #a1260d;
+        --vscode-debugIcon-disconnectForeground: #a1260d;
+        --vscode-debugIcon-restartForeground: #388a34;
+        --vscode-debugIcon-stepOverForeground: #007acc;
+        --vscode-debugIcon-stepIntoForeground: #007acc;
+        --vscode-debugIcon-stepOutForeground: #007acc;
+        --vscode-debugIcon-continueForeground: #007acc;
+        --vscode-debugIcon-stepBackForeground: #007acc;
+        --vscode-extensionButton-prominentBackground: #007acc;
+        --vscode-extensionButton-prominentForeground: #ffffff;
+        --vscode-extensionButton-prominentHoverBackground: #0062a3;
+        --vscode-extensionIcon-starForeground: #df6100;
+        --vscode-extensionIcon-verifiedForeground: #006ab1;
+        --vscode-extensionIcon-preReleaseForeground: #1d9271;
+        --vscode-extensionIcon-sponsorForeground: #b51e78;
+        --vscode-terminal-ansiBlack: #000000;
+        --vscode-terminal-ansiRed: #cd3131;
+        --vscode-terminal-ansiGreen: #00bc00;
+        --vscode-terminal-ansiYellow: #949800;
+        --vscode-terminal-ansiBlue: #0451a5;
+        --vscode-terminal-ansiMagenta: #bc05bc;
+        --vscode-terminal-ansiCyan: #0598bc;
+        --vscode-terminal-ansiWhite: #555555;
+        --vscode-terminal-ansiBrightBlack: #666666;
+        --vscode-terminal-ansiBrightRed: #cd3131;
+        --vscode-terminal-ansiBrightGreen: #14ce14;
+        --vscode-terminal-ansiBrightYellow: #b5ba00;
+        --vscode-terminal-ansiBrightBlue: #0451a5;
+        --vscode-terminal-ansiBrightMagenta: #bc05bc;
+        --vscode-terminal-ansiBrightCyan: #0598bc;
+        --vscode-terminal-ansiBrightWhite: #a5a5a5;
+        --vscode-interactive-activeCodeBorder: #1a85ff;
+        --vscode-interactive-inactiveCodeBorder: #e4e6f1;
+        --vscode-gitDecoration-addedResourceForeground: #587c0c;
+        --vscode-gitDecoration-modifiedResourceForeground: #895503;
+        --vscode-gitDecoration-deletedResourceForeground: #ad0707;
+        --vscode-gitDecoration-renamedResourceForeground: #007100;
+        --vscode-gitDecoration-untrackedResourceForeground: #007100;
+        --vscode-gitDecoration-ignoredResourceForeground: #8e8e90;
+        --vscode-gitDecoration-stageModifiedResourceForeground: #895503;
+        --vscode-gitDecoration-stageDeletedResourceForeground: #ad0707;
+        --vscode-gitDecoration-conflictingResourceForeground: #ad0707;
+        --vscode-gitDecoration-submoduleResourceForeground: #1258a7;
+      }
+      :root.light-mode {
+        color-scheme: light;
+      }
+      :root.dark-mode {
+        color-scheme: dark;
+        --vscode-font-family: system-ui, 'Ubuntu', 'Droid Sans', sans-serif;
+        --vscode-font-weight: normal;
+        --vscode-font-size: 13px;
+        --vscode-editor-font-family: 'Droid Sans Mono', 'monospace', monospace;
+        --vscode-editor-font-weight: normal;
+        --vscode-editor-font-size: 14px;
+        --vscode-foreground: #cccccc;
+        --vscode-disabledForeground: rgba(204, 204, 204, 0.5);
+        --vscode-errorForeground: #f48771;
+        --vscode-descriptionForeground: rgba(204, 204, 204, 0.7);
+        --vscode-icon-foreground: #c5c5c5;
+        --vscode-focusBorder: #007fd4;
+        --vscode-textSeparator-foreground: rgba(255, 255, 255, 0.18);
+        --vscode-textLink-foreground: #3794ff;
+        --vscode-textLink-activeForeground: #3794ff;
+        --vscode-textPreformat-foreground: #d7ba7d;
+        --vscode-textBlockQuote-background: rgba(127, 127, 127, 0.1);
+        --vscode-textBlockQuote-border: rgba(0, 122, 204, 0.5);
+        --vscode-textCodeBlock-background: rgba(10, 10, 10, 0.4);
+        --vscode-widget-shadow: rgba(0, 0, 0, 0.36);
+        --vscode-input-background: #3c3c3c;
+        --vscode-input-foreground: #cccccc;
+        --vscode-inputOption-activeBorder: #007acc;
+        --vscode-inputOption-hoverBackground: rgba(90, 93, 94, 0.5);
+        --vscode-inputOption-activeBackground: rgba(0, 127, 212, 0.4);
+        --vscode-inputOption-activeForeground: #ffffff;
+        --vscode-input-placeholderForeground: #a6a6a6;
+        --vscode-inputValidation-infoBackground: #063b49;
+        --vscode-inputValidation-infoBorder: #007acc;
+        --vscode-inputValidation-warningBackground: #352a05;
+        --vscode-inputValidation-warningBorder: #b89500;
+        --vscode-inputValidation-errorBackground: #5a1d1d;
+        --vscode-inputValidation-errorBorder: #be1100;
+        --vscode-dropdown-background: #3c3c3c;
+        --vscode-dropdown-foreground: #f0f0f0;
+        --vscode-dropdown-border: #3c3c3c;
+        --vscode-checkbox-background: #3c3c3c;
+        --vscode-checkbox-foreground: #f0f0f0;
+        --vscode-checkbox-border: #3c3c3c;
+        --vscode-button-foreground: #ffffff;
+        --vscode-button-separator: rgba(255, 255, 255, 0.4);
+        --vscode-button-background: #0e639c;
+        --vscode-button-hoverBackground: #1177bb;
+        --vscode-button-secondaryForeground: #ffffff;
+        --vscode-button-secondaryBackground: #3a3d41;
+        --vscode-button-secondaryHoverBackground: #45494e;
+        --vscode-badge-background: #4d4d4d;
+        --vscode-badge-foreground: #ffffff;
+        --vscode-scrollbar-shadow: #000000;
+        --vscode-scrollbarSlider-background: rgba(121, 121, 121, 0.4);
+        --vscode-scrollbarSlider-hoverBackground: rgba(100, 100, 100, 0.7);
+        --vscode-scrollbarSlider-activeBackground: rgba(191, 191, 191, 0.4);
+        --vscode-progressBar-background: #0e70c0;
+        --vscode-editorError-foreground: #f14c4c;
+        --vscode-editorWarning-foreground: #cca700;
+        --vscode-editorInfo-foreground: #3794ff;
+        --vscode-editorHint-foreground: rgba(238, 238, 238, 0.7);
+        --vscode-sash-hoverBorder: #007fd4;
+        --vscode-editor-background: #1e1e1e;
+        --vscode-editor-foreground: #d4d4d4;
+        --vscode-editorStickyScroll-background: #1e1e1e;
+        --vscode-editorStickyScrollHover-background: #2a2d2e;
+        --vscode-editorWidget-background: #252526;
+        --vscode-editorWidget-foreground: #cccccc;
+        --vscode-editorWidget-border: #454545;
+        --vscode-quickInput-background: #252526;
+        --vscode-quickInput-foreground: #cccccc;
+        --vscode-quickInputTitle-background: rgba(255, 255, 255, 0.1);
+        --vscode-pickerGroup-foreground: #3794ff;
+        --vscode-pickerGroup-border: #3f3f46;
+        --vscode-keybindingLabel-background: rgba(128, 128, 128, 0.17);
+        --vscode-keybindingLabel-foreground: #cccccc;
+        --vscode-keybindingLabel-border: rgba(51, 51, 51, 0.6);
+        --vscode-keybindingLabel-bottomBorder: rgba(68, 68, 68, 0.6);
+        --vscode-editor-selectionBackground: #264f78;
+        --vscode-editor-inactiveSelectionBackground: #3a3d41;
+        --vscode-editor-selectionHighlightBackground: rgba(173, 214, 255, 0.15);
+        --vscode-editor-findMatchBackground: #515c6a;
+        --vscode-editor-findMatchHighlightBackground: rgba(234, 92, 0, 0.33);
+        --vscode-editor-findRangeHighlightBackground: rgba(58, 61, 65, 0.4);
+        --vscode-searchEditor-findMatchBackground: rgba(234, 92, 0, 0.22);
+        --vscode-editor-hoverHighlightBackground: rgba(38, 79, 120, 0.25);
+        --vscode-editorHoverWidget-background: #252526;
+        --vscode-editorHoverWidget-foreground: #cccccc;
+        --vscode-editorHoverWidget-border: #454545;
+        --vscode-editorHoverWidget-statusBarBackground: #2c2c2d;
+        --vscode-editorLink-activeForeground: #4e94ce;
+        --vscode-editorInlayHint-foreground: rgba(255, 255, 255, 0.8);
+        --vscode-editorInlayHint-background: rgba(77, 77, 77, 0.6);
+        --vscode-editorInlayHint-typeForeground: rgba(255, 255, 255, 0.8);
+        --vscode-editorInlayHint-typeBackground: rgba(77, 77, 77, 0.6);
+        --vscode-editorInlayHint-parameterForeground: rgba(255, 255, 255, 0.8);
+        --vscode-editorInlayHint-parameterBackground: rgba(77, 77, 77, 0.6);
+        --vscode-editorLightBulb-foreground: #ffcc00;
+        --vscode-editorLightBulbAutoFix-foreground: #75beff;
+        --vscode-diffEditor-insertedTextBackground: rgba(156, 204, 44, 0.2);
+        --vscode-diffEditor-removedTextBackground: rgba(255, 0, 0, 0.4);
+        --vscode-diffEditor-insertedLineBackground: rgba(155, 185, 85, 0.2);
+        --vscode-diffEditor-removedLineBackground: rgba(255, 0, 0, 0.2);
+        --vscode-diffEditor-diagonalFill: rgba(204, 204, 204, 0.2);
+        --vscode-list-focusOutline: #007fd4;
+        --vscode-list-activeSelectionBackground: #04395e;
+        --vscode-list-activeSelectionForeground: #ffffff;
+        --vscode-list-activeSelectionIconForeground: #ffffff;
+        --vscode-list-inactiveSelectionBackground: #37373d;
+        --vscode-list-hoverBackground: #2a2d2e;
+        --vscode-list-dropBackground: #383b3d;
+        --vscode-list-highlightForeground: #2aaaff;
+        --vscode-list-focusHighlightForeground: #2aaaff;
+        --vscode-list-invalidItemForeground: #b89500;
+        --vscode-list-errorForeground: #f88070;
+        --vscode-list-warningForeground: #cca700;
+        --vscode-listFilterWidget-background: #252526;
+        --vscode-listFilterWidget-outline: rgba(0, 0, 0, 0);
+        --vscode-listFilterWidget-noMatchesOutline: #be1100;
+        --vscode-listFilterWidget-shadow: rgba(0, 0, 0, 0.36);
+        --vscode-list-filterMatchBackground: rgba(234, 92, 0, 0.33);
+        --vscode-tree-indentGuidesStroke: #585858;
+        --vscode-tree-tableColumnsBorder: rgba(204, 204, 204, 0.13);
+        --vscode-tree-tableOddRowsBackground: rgba(204, 204, 204, 0.04);
+        --vscode-list-deemphasizedForeground: #8c8c8c;
+        --vscode-quickInputList-focusForeground: #ffffff;
+        --vscode-quickInputList-focusIconForeground: #ffffff;
+        --vscode-quickInputList-focusBackground: #04395e;
+        --vscode-menu-foreground: #cccccc;
+        --vscode-menu-background: #303031;
+        --vscode-menu-selectionForeground: #ffffff;
+        --vscode-menu-selectionBackground: #04395e;
+        --vscode-menu-separatorBackground: #606060;
+        --vscode-toolbar-hoverBackground: rgba(90, 93, 94, 0.31);
+        --vscode-toolbar-activeBackground: rgba(99, 102, 103, 0.31);
+        --vscode-editor-snippetTabstopHighlightBackground: rgba(
+          124,
+          124,
+          124,
+          0.3
+        );
+        --vscode-editor-snippetFinalTabstopHighlightBorder: #525252;
+        --vscode-breadcrumb-foreground: rgba(204, 204, 204, 0.8);
+        --vscode-breadcrumb-background: #1e1e1e;
+        --vscode-breadcrumb-focusForeground: #e0e0e0;
+        --vscode-breadcrumb-activeSelectionForeground: #e0e0e0;
+        --vscode-breadcrumbPicker-background: #252526;
+        --vscode-merge-currentHeaderBackground: rgba(64, 200, 174, 0.5);
+        --vscode-merge-currentContentBackground: rgba(64, 200, 174, 0.2);
+        --vscode-merge-incomingHeaderBackground: rgba(64, 166, 255, 0.5);
+        --vscode-merge-incomingContentBackground: rgba(64, 166, 255, 0.2);
+        --vscode-merge-commonHeaderBackground: rgba(96, 96, 96, 0.4);
+        --vscode-merge-commonContentBackground: rgba(96, 96, 96, 0.16);
+        --vscode-editorOverviewRuler-currentContentForeground: rgba(
+          64,
+          200,
+          174,
+          0.5
+        );
+        --vscode-editorOverviewRuler-incomingContentForeground: rgba(
+          64,
+          166,
+          255,
+          0.5
+        );
+        --vscode-editorOverviewRuler-commonContentForeground: rgba(
+          96,
+          96,
+          96,
+          0.4
+        );
+        --vscode-editorOverviewRuler-findMatchForeground: rgba(
+          209,
+          134,
+          22,
+          0.49
+        );
+        --vscode-editorOverviewRuler-selectionHighlightForeground: rgba(
+          160,
+          160,
+          160,
+          0.8
+        );
+        --vscode-minimap-findMatchHighlight: #d18616;
+        --vscode-minimap-selectionOccurrenceHighlight: #676767;
+        --vscode-minimap-selectionHighlight: #264f78;
+        --vscode-minimap-errorHighlight: rgba(255, 18, 18, 0.7);
+        --vscode-minimap-warningHighlight: #cca700;
+        --vscode-minimap-foregroundOpacity: #000000;
+        --vscode-minimapSlider-background: rgba(121, 121, 121, 0.2);
+        --vscode-minimapSlider-hoverBackground: rgba(100, 100, 100, 0.35);
+        --vscode-minimapSlider-activeBackground: rgba(191, 191, 191, 0.2);
+        --vscode-problemsErrorIcon-foreground: #f14c4c;
+        --vscode-problemsWarningIcon-foreground: #cca700;
+        --vscode-problemsInfoIcon-foreground: #3794ff;
+        --vscode-charts-foreground: #cccccc;
+        --vscode-charts-lines: rgba(204, 204, 204, 0.5);
+        --vscode-charts-red: #f14c4c;
+        --vscode-charts-blue: #3794ff;
+        --vscode-charts-yellow: #cca700;
+        --vscode-charts-orange: #d18616;
+        --vscode-charts-green: #89d185;
+        --vscode-charts-purple: #b180d7;
+        --vscode-editor-lineHighlightBorder: #282828;
+        --vscode-editor-rangeHighlightBackground: rgba(255, 255, 255, 0.04);
+        --vscode-editor-symbolHighlightBackground: rgba(234, 92, 0, 0.33);
+        --vscode-editorCursor-foreground: #aeafad;
+        --vscode-editorWhitespace-foreground: rgba(227, 228, 226, 0.16);
+        --vscode-editorIndentGuide-background: #404040;
+        --vscode-editorIndentGuide-activeBackground: #707070;
+        --vscode-editorLineNumber-foreground: #858585;
+        --vscode-editorActiveLineNumber-foreground: #c6c6c6;
+        --vscode-editorLineNumber-activeForeground: #c6c6c6;
+        --vscode-editorRuler-foreground: #5a5a5a;
+        --vscode-editorCodeLens-foreground: #999999;
+        --vscode-editorBracketMatch-background: rgba(0, 100, 0, 0.1);
+        --vscode-editorBracketMatch-border: #888888;
+        --vscode-editorOverviewRuler-border: rgba(127, 127, 127, 0.3);
+        --vscode-editorGutter-background: #1e1e1e;
+        --vscode-editorUnnecessaryCode-opacity: rgba(0, 0, 0, 0.67);
+        --vscode-editorGhostText-foreground: rgba(255, 255, 255, 0.34);
+        --vscode-editorOverviewRuler-rangeHighlightForeground: rgba(
+          0,
+          122,
+          204,
+          0.6
+        );
+        --vscode-editorOverviewRuler-errorForeground: rgba(255, 18, 18, 0.7);
+        --vscode-editorOverviewRuler-warningForeground: #cca700;
+        --vscode-editorOverviewRuler-infoForeground: #3794ff;
+        --vscode-editorBracketHighlight-foreground1: #ffd700;
+        --vscode-editorBracketHighlight-foreground2: #da70d6;
+        --vscode-editorBracketHighlight-foreground3: #179fff;
+        --vscode-editorBracketHighlight-foreground4: rgba(0, 0, 0, 0);
+        --vscode-editorBracketHighlight-foreground5: rgba(0, 0, 0, 0);
+        --vscode-editorBracketHighlight-foreground6: rgba(0, 0, 0, 0);
+        --vscode-editorBracketHighlight-unexpectedBracket\.foreground: rgba(
+          255,
+          18,
+          18,
+          0.8
+        );
+        --vscode-editorBracketPairGuide-background1: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-background2: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-background3: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-background4: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-background5: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-background6: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-activeBackground1: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-activeBackground2: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-activeBackground3: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-activeBackground4: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-activeBackground5: rgba(0, 0, 0, 0);
+        --vscode-editorBracketPairGuide-activeBackground6: rgba(0, 0, 0, 0);
+        --vscode-editorUnicodeHighlight-border: #bd9b03;
+        --vscode-editorUnicodeHighlight-background: rgba(189, 155, 3, 0.15);
+        --vscode-symbolIcon-arrayForeground: #cccccc;
+        --vscode-symbolIcon-booleanForeground: #cccccc;
+        --vscode-symbolIcon-classForeground: #ee9d28;
+        --vscode-symbolIcon-colorForeground: #cccccc;
+        --vscode-symbolIcon-constantForeground: #cccccc;
+        --vscode-symbolIcon-constructorForeground: #b180d7;
+        --vscode-symbolIcon-enumeratorForeground: #ee9d28;
+        --vscode-symbolIcon-enumeratorMemberForeground: #75beff;
+        --vscode-symbolIcon-eventForeground: #ee9d28;
+        --vscode-symbolIcon-fieldForeground: #75beff;
+        --vscode-symbolIcon-fileForeground: #cccccc;
+        --vscode-symbolIcon-folderForeground: #cccccc;
+        --vscode-symbolIcon-functionForeground: #b180d7;
+        --vscode-symbolIcon-interfaceForeground: #75beff;
+        --vscode-symbolIcon-keyForeground: #cccccc;
+        --vscode-symbolIcon-keywordForeground: #cccccc;
+        --vscode-symbolIcon-methodForeground: #b180d7;
+        --vscode-symbolIcon-moduleForeground: #cccccc;
+        --vscode-symbolIcon-namespaceForeground: #cccccc;
+        --vscode-symbolIcon-nullForeground: #cccccc;
+        --vscode-symbolIcon-numberForeground: #cccccc;
+        --vscode-symbolIcon-objectForeground: #cccccc;
+        --vscode-symbolIcon-operatorForeground: #cccccc;
+        --vscode-symbolIcon-packageForeground: #cccccc;
+        --vscode-symbolIcon-propertyForeground: #cccccc;
+        --vscode-symbolIcon-referenceForeground: #cccccc;
+        --vscode-symbolIcon-snippetForeground: #cccccc;
+        --vscode-symbolIcon-stringForeground: #cccccc;
+        --vscode-symbolIcon-structForeground: #cccccc;
+        --vscode-symbolIcon-textForeground: #cccccc;
+        --vscode-symbolIcon-typeParameterForeground: #cccccc;
+        --vscode-symbolIcon-unitForeground: #cccccc;
+        --vscode-symbolIcon-variableForeground: #75beff;
+        --vscode-editorHoverWidget-highlightForeground: #2aaaff;
+        --vscode-editorOverviewRuler-bracketMatchForeground: #a0a0a0;
+        --vscode-editor-foldBackground: rgba(38, 79, 120, 0.3);
+        --vscode-editorGutter-foldingControlForeground: #c5c5c5;
+        --vscode-editor-linkedEditingBackground: rgba(255, 0, 0, 0.3);
+        --vscode-editor-wordHighlightBackground: rgba(87, 87, 87, 0.72);
+        --vscode-editor-wordHighlightStrongBackground: rgba(0, 73, 114, 0.72);
+        --vscode-editorOverviewRuler-wordHighlightForeground: rgba(
+          160,
+          160,
+          160,
+          0.8
+        );
+        --vscode-editorOverviewRuler-wordHighlightStrongForeground: rgba(
+          192,
+          160,
+          192,
+          0.8
+        );
+        --vscode-peekViewTitle-background: rgba(55, 148, 255, 0.1);
+        --vscode-peekViewTitleLabel-foreground: #ffffff;
+        --vscode-peekViewTitleDescription-foreground: rgba(204, 204, 204, 0.7);
+        --vscode-peekView-border: #3794ff;
+        --vscode-peekViewResult-background: #252526;
+        --vscode-peekViewResult-lineForeground: #bbbbbb;
+        --vscode-peekViewResult-fileForeground: #ffffff;
+        --vscode-peekViewResult-selectionBackground: rgba(51, 153, 255, 0.2);
+        --vscode-peekViewResult-selectionForeground: #ffffff;
+        --vscode-peekViewEditor-background: #001f33;
+        --vscode-peekViewEditorGutter-background: #001f33;
+        --vscode-peekViewResult-matchHighlightBackground: rgba(234, 92, 0, 0.3);
+        --vscode-peekViewEditor-matchHighlightBackground: rgba(
+          255,
+          143,
+          0,
+          0.6
+        );
+        --vscode-editorMarkerNavigationError-background: #f14c4c;
+        --vscode-editorMarkerNavigationError-headerBackground: rgba(
+          241,
+          76,
+          76,
+          0.1
+        );
+        --vscode-editorMarkerNavigationWarning-background: #cca700;
+        --vscode-editorMarkerNavigationWarning-headerBackground: rgba(
+          204,
+          167,
+          0,
+          0.1
+        );
+        --vscode-editorMarkerNavigationInfo-background: #3794ff;
+        --vscode-editorMarkerNavigationInfo-headerBackground: rgba(
+          55,
+          148,
+          255,
+          0.1
+        );
+        --vscode-editorMarkerNavigation-background: #1e1e1e;
+        --vscode-editorSuggestWidget-background: #252526;
+        --vscode-editorSuggestWidget-border: #454545;
+        --vscode-editorSuggestWidget-foreground: #d4d4d4;
+        --vscode-editorSuggestWidget-selectedForeground: #ffffff;
+        --vscode-editorSuggestWidget-selectedIconForeground: #ffffff;
+        --vscode-editorSuggestWidget-selectedBackground: #04395e;
+        --vscode-editorSuggestWidget-highlightForeground: #2aaaff;
+        --vscode-editorSuggestWidget-focusHighlightForeground: #2aaaff;
+        --vscode-editorSuggestWidgetStatus-foreground: rgba(212, 212, 212, 0.5);
+        --vscode-tab-activeBackground: #1e1e1e;
+        --vscode-tab-unfocusedActiveBackground: #1e1e1e;
+        --vscode-tab-inactiveBackground: #2d2d2d;
+        --vscode-tab-unfocusedInactiveBackground: #2d2d2d;
+        --vscode-tab-activeForeground: #ffffff;
+        --vscode-tab-inactiveForeground: rgba(255, 255, 255, 0.5);
+        --vscode-tab-unfocusedActiveForeground: rgba(255, 255, 255, 0.5);
+        --vscode-tab-unfocusedInactiveForeground: rgba(255, 255, 255, 0.25);
+        --vscode-tab-border: #252526;
+        --vscode-tab-lastPinnedBorder: rgba(204, 204, 204, 0.2);
+        --vscode-tab-activeModifiedBorder: #3399cc;
+        --vscode-tab-inactiveModifiedBorder: rgba(51, 153, 204, 0.5);
+        --vscode-tab-unfocusedActiveModifiedBorder: rgba(51, 153, 204, 0.5);
+        --vscode-tab-unfocusedInactiveModifiedBorder: rgba(51, 153, 204, 0.25);
+        --vscode-editorPane-background: #1e1e1e;
+        --vscode-editorGroupHeader-tabsBackground: #252526;
+        --vscode-editorGroupHeader-noTabsBackground: #1e1e1e;
+        --vscode-editorGroup-border: #444444;
+        --vscode-editorGroup-dropBackground: rgba(83, 89, 93, 0.5);
+        --vscode-editorGroup-dropIntoPromptForeground: #cccccc;
+        --vscode-editorGroup-dropIntoPromptBackground: #252526;
+        --vscode-sideBySideEditor-horizontalBorder: #444444;
+        --vscode-sideBySideEditor-verticalBorder: #444444;
+        --vscode-panel-background: #1e1e1e;
+        --vscode-panel-border: rgba(128, 128, 128, 0.35);
+        --vscode-panelTitle-activeForeground: #e7e7e7;
+        --vscode-panelTitle-inactiveForeground: rgba(231, 231, 231, 0.6);
+        --vscode-panelTitle-activeBorder: #e7e7e7;
+        --vscode-panel-dropBorder: #e7e7e7;
+        --vscode-panelSection-dropBackground: rgba(83, 89, 93, 0.5);
+        --vscode-panelSectionHeader-background: rgba(128, 128, 128, 0.2);
+        --vscode-panelSection-border: rgba(128, 128, 128, 0.35);
+        --vscode-banner-background: #04395e;
+        --vscode-banner-foreground: #ffffff;
+        --vscode-banner-iconForeground: #3794ff;
+        --vscode-statusBar-foreground: #ffffff;
+        --vscode-statusBar-noFolderForeground: #ffffff;
+        --vscode-statusBar-background: #007acc;
+        --vscode-statusBar-noFolderBackground: #68217a;
+        --vscode-statusBar-focusBorder: #ffffff;
+        --vscode-statusBarItem-activeBackground: rgba(255, 255, 255, 0.18);
+        --vscode-statusBarItem-focusBorder: #ffffff;
+        --vscode-statusBarItem-hoverBackground: rgba(255, 255, 255, 0.12);
+        --vscode-statusBarItem-compactHoverBackground: rgba(255, 255, 255, 0.2);
+        --vscode-statusBarItem-prominentForeground: #ffffff;
+        --vscode-statusBarItem-prominentBackground: rgba(0, 0, 0, 0.5);
+        --vscode-statusBarItem-prominentHoverBackground: rgba(0, 0, 0, 0.3);
+        --vscode-statusBarItem-errorBackground: #c72e0f;
+        --vscode-statusBarItem-errorForeground: #ffffff;
+        --vscode-statusBarItem-warningBackground: #7a6400;
+        --vscode-statusBarItem-warningForeground: #ffffff;
+        --vscode-activityBar-background: #333333;
+        --vscode-activityBar-foreground: #ffffff;
+        --vscode-activityBar-inactiveForeground: rgba(255, 255, 255, 0.4);
+        --vscode-activityBar-activeBorder: #ffffff;
+        --vscode-activityBar-dropBorder: #ffffff;
+        --vscode-activityBarBadge-background: #007acc;
+        --vscode-activityBarBadge-foreground: #ffffff;
+        --vscode-statusBarItem-remoteBackground: #16825d;
+        --vscode-statusBarItem-remoteForeground: #ffffff;
+        --vscode-extensionBadge-remoteBackground: #007acc;
+        --vscode-extensionBadge-remoteForeground: #ffffff;
+        --vscode-sideBar-background: #252526;
+        --vscode-sideBarTitle-foreground: #bbbbbb;
+        --vscode-sideBar-dropBackground: rgba(83, 89, 93, 0.5);
+        --vscode-sideBarSectionHeader-background: rgba(0, 0, 0, 0);
+        --vscode-sideBarSectionHeader-border: rgba(204, 204, 204, 0.2);
+        --vscode-titleBar-activeForeground: #cccccc;
+        --vscode-titleBar-inactiveForeground: rgba(204, 204, 204, 0.6);
+        --vscode-titleBar-activeBackground: #3c3c3c;
+        --vscode-titleBar-inactiveBackground: rgba(60, 60, 60, 0.6);
+        --vscode-menubar-selectionForeground: #cccccc;
+        --vscode-menubar-selectionBackground: rgba(90, 93, 94, 0.31);
+        --vscode-notifications-foreground: #cccccc;
+        --vscode-notifications-background: #252526;
+        --vscode-notificationLink-foreground: #3794ff;
+        --vscode-notificationCenterHeader-background: #303031;
+        --vscode-notifications-border: #303031;
+        --vscode-notificationsErrorIcon-foreground: #f14c4c;
+        --vscode-notificationsWarningIcon-foreground: #cca700;
+        --vscode-notificationsInfoIcon-foreground: #3794ff;
+        --vscode-commandCenter-foreground: #cccccc;
+        --vscode-commandCenter-activeForeground: #cccccc;
+        --vscode-commandCenter-activeBackground: rgba(90, 93, 94, 0.31);
+        --vscode-commandCenter-border: rgba(128, 128, 128, 0.35);
+        --vscode-editorCommentsWidget-resolvedBorder: rgba(204, 204, 204, 0.5);
+        --vscode-editorCommentsWidget-unresolvedBorder: #3794ff;
+        --vscode-editorCommentsWidget-rangeBackground: rgba(55, 148, 255, 0.1);
+        --vscode-editorCommentsWidget-rangeBorder: rgba(55, 148, 255, 0.4);
+        --vscode-editorCommentsWidget-rangeActiveBackground: rgba(
+          55,
+          148,
+          255,
+          0.1
+        );
+        --vscode-editorCommentsWidget-rangeActiveBorder: rgba(
+          55,
+          148,
+          255,
+          0.4
+        );
+        --vscode-editorGutter-commentRangeForeground: #37373d;
+        --vscode-debugToolBar-background: #333333;
+        --vscode-debugIcon-startForeground: #89d185;
+        --vscode-editor-stackFrameHighlightBackground: rgba(255, 255, 0, 0.2);
+        --vscode-editor-focusedStackFrameHighlightBackground: rgba(
+          122,
+          189,
+          122,
+          0.3
+        );
+        --vscode-mergeEditor-change\.background: rgba(155, 185, 85, 0.2);
+        --vscode-mergeEditor-change\.word\.background: rgba(156, 204, 44, 0.2);
+        --vscode-mergeEditor-conflict\.unhandledUnfocused\.border: rgba(
+          255,
+          166,
+          0,
+          0.48
+        );
+        --vscode-mergeEditor-conflict\.unhandledFocused\.border: #ffa600;
+        --vscode-mergeEditor-conflict\.handledUnfocused\.border: rgba(
+          134,
+          134,
+          134,
+          0.29
+        );
+        --vscode-mergeEditor-conflict\.handledFocused\.border: rgba(
+          193,
+          193,
+          193,
+          0.8
+        );
+        --vscode-mergeEditor-conflict\.handled\.minimapOverViewRuler: rgba(
+          173,
+          172,
+          168,
+          0.93
+        );
+        --vscode-mergeEditor-conflict\.unhandled\.minimapOverViewRuler: #fcba03;
+        --vscode-mergeEditor-conflictingLines\.background: rgba(
+          255,
+          234,
+          0,
+          0.28
+        );
+        --vscode-settings-headerForeground: #e7e7e7;
+        --vscode-settings-modifiedItemIndicator: #0c7d9d;
+        --vscode-settings-headerBorder: rgba(128, 128, 128, 0.35);
+        --vscode-settings-sashBorder: rgba(128, 128, 128, 0.35);
+        --vscode-settings-dropdownBackground: #3c3c3c;
+        --vscode-settings-dropdownForeground: #f0f0f0;
+        --vscode-settings-dropdownBorder: #3c3c3c;
+        --vscode-settings-dropdownListBorder: #454545;
+        --vscode-settings-checkboxBackground: #3c3c3c;
+        --vscode-settings-checkboxForeground: #f0f0f0;
+        --vscode-settings-checkboxBorder: #3c3c3c;
+        --vscode-settings-textInputBackground: #3c3c3c;
+        --vscode-settings-textInputForeground: #cccccc;
+        --vscode-settings-numberInputBackground: #3c3c3c;
+        --vscode-settings-numberInputForeground: #cccccc;
+        --vscode-settings-focusedRowBackground: rgba(42, 45, 46, 0.6);
+        --vscode-settings-rowHoverBackground: rgba(42, 45, 46, 0.3);
+        --vscode-settings-focusedRowBorder: rgba(255, 255, 255, 0.12);
+        --vscode-terminal-foreground: #cccccc;
+        --vscode-terminal-selectionBackground: #264f78;
+        --vscode-terminal-inactiveSelectionBackground: #3a3d41;
+        --vscode-terminalCommandDecoration-defaultBackground: rgba(
+          255,
+          255,
+          255,
+          0.25
+        );
+        --vscode-terminalCommandDecoration-successBackground: #1b81a8;
+        --vscode-terminalCommandDecoration-errorBackground: #f14c4c;
+        --vscode-terminalOverviewRuler-cursorForeground: rgba(
+          160,
+          160,
+          160,
+          0.8
+        );
+        --vscode-terminal-border: rgba(128, 128, 128, 0.35);
+        --vscode-terminal-findMatchBackground: #515c6a;
+        --vscode-terminal-findMatchHighlightBackground: rgba(234, 92, 0, 0.33);
+        --vscode-terminalOverviewRuler-findMatchForeground: rgba(
+          209,
+          134,
+          22,
+          0.49
+        );
+        --vscode-terminal-dropBackground: rgba(83, 89, 93, 0.5);
+        --vscode-testing-iconFailed: #f14c4c;
+        --vscode-testing-iconErrored: #f14c4c;
+        --vscode-testing-iconPassed: #73c991;
+        --vscode-testing-runAction: #73c991;
+        --vscode-testing-iconQueued: #cca700;
+        --vscode-testing-iconUnset: #848484;
+        --vscode-testing-iconSkipped: #848484;
+        --vscode-testing-peekBorder: #f14c4c;
+        --vscode-testing-peekHeaderBackground: rgba(241, 76, 76, 0.1);
+        --vscode-testing-message\.error\.decorationForeground: #f14c4c;
+        --vscode-testing-message\.error\.lineBackground: rgba(255, 0, 0, 0.2);
+        --vscode-testing-message\.info\.decorationForeground: rgba(
+          212,
+          212,
+          212,
+          0.5
+        );
+        --vscode-welcomePage-tileBackground: #252526;
+        --vscode-welcomePage-tileHoverBackground: #2c2c2d;
+        --vscode-welcomePage-tileShadow: rgba(0, 0, 0, 0.36);
+        --vscode-welcomePage-progress\.background: #3c3c3c;
+        --vscode-welcomePage-progress\.foreground: #3794ff;
+        --vscode-debugExceptionWidget-border: #a31515;
+        --vscode-debugExceptionWidget-background: #420b0d;
+        --vscode-ports-iconRunningProcessForeground: #369432;
+        --vscode-statusBar-debuggingBackground: #cc6633;
+        --vscode-statusBar-debuggingForeground: #ffffff;
+        --vscode-editor-inlineValuesForeground: rgba(255, 255, 255, 0.5);
+        --vscode-editor-inlineValuesBackground: rgba(255, 200, 0, 0.2);
+        --vscode-editorGutter-modifiedBackground: #1b81a8;
+        --vscode-editorGutter-addedBackground: #487e02;
+        --vscode-editorGutter-deletedBackground: #f14c4c;
+        --vscode-minimapGutter-modifiedBackground: #1b81a8;
+        --vscode-minimapGutter-addedBackground: #487e02;
+        --vscode-minimapGutter-deletedBackground: #f14c4c;
+        --vscode-editorOverviewRuler-modifiedForeground: rgba(
+          27,
+          129,
+          168,
+          0.6
+        );
+        --vscode-editorOverviewRuler-addedForeground: rgba(72, 126, 2, 0.6);
+        --vscode-editorOverviewRuler-deletedForeground: rgba(241, 76, 76, 0.6);
+        --vscode-debugIcon-breakpointForeground: #e51400;
+        --vscode-debugIcon-breakpointDisabledForeground: #848484;
+        --vscode-debugIcon-breakpointUnverifiedForeground: #848484;
+        --vscode-debugIcon-breakpointCurrentStackframeForeground: #ffcc00;
+        --vscode-debugIcon-breakpointStackframeForeground: #89d185;
+        --vscode-notebook-cellBorderColor: #37373d;
+        --vscode-notebook-focusedEditorBorder: #007fd4;
+        --vscode-notebookStatusSuccessIcon-foreground: #89d185;
+        --vscode-notebookStatusErrorIcon-foreground: #f48771;
+        --vscode-notebookStatusRunningIcon-foreground: #cccccc;
+        --vscode-notebook-cellToolbarSeparator: rgba(128, 128, 128, 0.35);
+        --vscode-notebook-selectedCellBackground: #37373d;
+        --vscode-notebook-selectedCellBorder: #37373d;
+        --vscode-notebook-focusedCellBorder: #007fd4;
+        --vscode-notebook-inactiveFocusedCellBorder: #37373d;
+        --vscode-notebook-cellStatusBarItemHoverBackground: rgba(
+          255,
+          255,
+          255,
+          0.15
+        );
+        --vscode-notebook-cellInsertionIndicator: #007fd4;
+        --vscode-notebookScrollbarSlider-background: rgba(121, 121, 121, 0.4);
+        --vscode-notebookScrollbarSlider-hoverBackground: rgba(
+          100,
+          100,
+          100,
+          0.7
+        );
+        --vscode-notebookScrollbarSlider-activeBackground: rgba(
+          191,
+          191,
+          191,
+          0.4
+        );
+        --vscode-notebook-symbolHighlightBackground: rgba(255, 255, 255, 0.04);
+        --vscode-notebook-cellEditorBackground: #252526;
+        --vscode-notebook-editorBackground: #1e1e1e;
+        --vscode-keybindingTable-headerBackground: rgba(204, 204, 204, 0.04);
+        --vscode-keybindingTable-rowsBackground: rgba(204, 204, 204, 0.04);
+        --vscode-scm-providerBorder: #454545;
+        --vscode-debugTokenExpression-name: #c586c0;
+        --vscode-debugTokenExpression-value: rgba(204, 204, 204, 0.6);
+        --vscode-debugTokenExpression-string: #ce9178;
+        --vscode-debugTokenExpression-boolean: #4e94ce;
+        --vscode-debugTokenExpression-number: #b5cea8;
+        --vscode-debugTokenExpression-error: #f48771;
+        --vscode-debugView-exceptionLabelForeground: #cccccc;
+        --vscode-debugView-exceptionLabelBackground: #6c2022;
+        --vscode-debugView-stateLabelForeground: #cccccc;
+        --vscode-debugView-stateLabelBackground: rgba(136, 136, 136, 0.27);
+        --vscode-debugView-valueChangedHighlight: #569cd6;
+        --vscode-debugConsole-infoForeground: #3794ff;
+        --vscode-debugConsole-warningForeground: #cca700;
+        --vscode-debugConsole-errorForeground: #f48771;
+        --vscode-debugConsole-sourceForeground: #cccccc;
+        --vscode-debugConsoleInputIcon-foreground: #cccccc;
+        --vscode-debugIcon-pauseForeground: #75beff;
+        --vscode-debugIcon-stopForeground: #f48771;
+        --vscode-debugIcon-disconnectForeground: #f48771;
+        --vscode-debugIcon-restartForeground: #89d185;
+        --vscode-debugIcon-stepOverForeground: #75beff;
+        --vscode-debugIcon-stepIntoForeground: #75beff;
+        --vscode-debugIcon-stepOutForeground: #75beff;
+        --vscode-debugIcon-continueForeground: #75beff;
+        --vscode-debugIcon-stepBackForeground: #75beff;
+        --vscode-extensionButton-prominentBackground: #0e639c;
+        --vscode-extensionButton-prominentForeground: #ffffff;
+        --vscode-extensionButton-prominentHoverBackground: #1177bb;
+        --vscode-extensionIcon-starForeground: #ff8e00;
+        --vscode-extensionIcon-verifiedForeground: #3794ff;
+        --vscode-extensionIcon-preReleaseForeground: #1d9271;
+        --vscode-extensionIcon-sponsorForeground: #d758b3;
+        --vscode-terminal-ansiBlack: #000000;
+        --vscode-terminal-ansiRed: #cd3131;
+        --vscode-terminal-ansiGreen: #0dbc79;
+        --vscode-terminal-ansiYellow: #e5e510;
+        --vscode-terminal-ansiBlue: #2472c8;
+        --vscode-terminal-ansiMagenta: #bc3fbc;
+        --vscode-terminal-ansiCyan: #11a8cd;
+        --vscode-terminal-ansiWhite: #e5e5e5;
+        --vscode-terminal-ansiBrightBlack: #666666;
+        --vscode-terminal-ansiBrightRed: #f14c4c;
+        --vscode-terminal-ansiBrightGreen: #23d18b;
+        --vscode-terminal-ansiBrightYellow: #f5f543;
+        --vscode-terminal-ansiBrightBlue: #3b8eea;
+        --vscode-terminal-ansiBrightMagenta: #d670d6;
+        --vscode-terminal-ansiBrightCyan: #29b8db;
+        --vscode-terminal-ansiBrightWhite: #e5e5e5;
+        --vscode-interactive-activeCodeBorder: #3794ff;
+        --vscode-interactive-inactiveCodeBorder: #37373d;
+        --vscode-gitDecoration-addedResourceForeground: #81b88b;
+        --vscode-gitDecoration-modifiedResourceForeground: #e2c08d;
+        --vscode-gitDecoration-deletedResourceForeground: #c74e39;
+        --vscode-gitDecoration-renamedResourceForeground: #73c991;
+        --vscode-gitDecoration-untrackedResourceForeground: #73c991;
+        --vscode-gitDecoration-ignoredResourceForeground: #8c8c8c;
+        --vscode-gitDecoration-stageModifiedResourceForeground: #e2c08d;
+        --vscode-gitDecoration-stageDeletedResourceForeground: #c74e39;
+        --vscode-gitDecoration-conflictingResourceForeground: #e4676b;
+        --vscode-gitDecoration-submoduleResourceForeground: #8db9e2;
+      }
+      .test-error-container {
+        position: relative;
+        white-space: pre;
+        flex: none;
+        padding: 0;
+        background-color: var(--color-canvas-subtle);
+        border-radius: 6px;
+        line-height: initial;
+        margin-bottom: 6px;
+      }
+      .test-error-view {
+        overflow: auto;
+        padding: 16px;
+      }
+      .test-error-text {
+        font-family: monospace;
+      }
+      .test-result {
+        flex: auto;
+        display: flex;
+        flex-direction: column;
+        margin-bottom: 24px;
+      }
+      .test-result > div {
+        flex: none;
+      }
+      .test-result video,
+      .test-result img.screenshot {
+        flex: none;
+        box-shadow: var(--box-shadow-thick);
+        margin: 24px auto;
+        min-width: 200px;
+        max-width: 80%;
+      }
+      .test-result-path {
+        padding: 0 0 0 5px;
+        color: var(--color-fg-muted);
+      }
+      .test-result-counter {
+        border-radius: 12px;
+        color: var(--color-canvas-default);
+        padding: 2px 8px;
+      }
+      :root.light-mode .test-result-counter {
+        background: var(--color-scale-gray-5);
+      }
+      :root.dark-mode .test-result-counter {
+        background: var(--color-scale-gray-3);
+      }
+      @media only screen and (max-width: 600px) {
+        .test-result {
+          padding: 0 !important;
+        }
+      }
+      .test-file-test {
+        line-height: 32px;
+        align-items: center;
+        padding: 2px 8px;
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
+      .test-file-test:hover {
+        background-color: var(--color-canvas-subtle);
+      }
+      .test-file-title {
+        font-weight: 600;
+        font-size: 16px;
+      }
+      .test-file-details-row {
+        padding: 0 0 6px 8px;
+        margin: 0 0 0 15px;
+        line-height: 16px;
+        font-weight: 400;
+        color: var(--color-fg-muted);
+        display: flex;
+        align-items: center;
+      }
+      .test-file-details-row-items {
+        display: flex;
+        height: 16px;
+      }
+      .test-file-details-row-items > .link-badge {
+        margin-top: -2px;
+      }
+      .test-file-details-row-items > .trace-link {
+        margin-top: -4px;
+      }
+      .test-file-path {
+        text-overflow: ellipsis;
+        overflow: hidden;
+        color: var(--color-fg-muted);
+      }
+      .test-file-path-link {
+        margin-right: 10px;
+      }
+      .test-file-test-outcome-skipped {
+        color: var(--color-fg-muted);
+      }
+      .test-file-test-status-icon {
+        flex: none;
+      }
+      .test-file-header-info {
+        display: flex;
+        align-items: center;
+        gap: 4px 8px;
+        color: var(--color-fg-muted);
+      }
+      .test-file-header-br {
+        flex-basis: 100%;
+        height: 0;
+      }
+      .test-file-no-files {
+        margin-top: 12px;
+        color: var(--color-fg-muted);
+        background-color: unset;
+        font-weight: unset;
+        border: 1px solid var(--color-border-default);
+        border-bottom-left-radius: 6px;
+        border-bottom-right-radius: 6px;
+      }
+      #root {
+        color: var(--color-fg-default);
+        font-size: 14px;
+        font-family:
+          -apple-system,
+          BlinkMacSystemFont,
+          Segoe UI,
+          Helvetica,
+          Arial,
+          sans-serif,
+          'Apple Color Emoji',
+          'Segoe UI Emoji';
+        -webkit-font-smoothing: antialiased;
+      }
+      .metadata-toggle {
+        cursor: pointer;
+        -webkit-user-select: none;
+        user-select: none;
+        color: var(--color-fg-default);
+      }
+      .metadata-toggle-second-line {
+        margin-top: 8px;
+        margin-left: 8px;
+      }
+      .metadata-view {
+        border: 1px solid var(--color-border-default);
+        border-radius: 6px;
+        margin-top: 12px;
+      }
+      .metadata-view .metadata-section {
+        margin: 8px 10px 8px 32px;
+      }
+      .metadata-view span:not(.copy-button-container),
+      .metadata-view a {
+        display: inline-block;
+        line-height: 24px;
+      }
+      .metadata-properties {
+        display: flex;
+        flex-direction: column;
+        align-items: normal;
+        gap: 8px;
+      }
+      .metadata-properties > div {
+        height: 24px;
+      }
+      .metadata-separator {
+        height: 1px;
+        border-bottom: 1px solid var(--color-border-default);
+      }
+      .metadata-view a {
+        color: var(--color-fg-default);
+      }
+      .copyable-property {
+        white-space: pre;
+      }
+      .copyable-property > span {
+        display: flex;
+        align-items: center;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>
+<script id="playwrightReportBase64" type="application/zip">
+  data:application/zip;base64,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
+</script>
diff --git a/testing/panel/playwright.config.ts b/testing/panel/playwright.config.ts
new file mode 100644
index 00000000..3dde9529
--- /dev/null
+++ b/testing/panel/playwright.config.ts
@@ -0,0 +1,46 @@
+import { defineConfig, devices } from '@playwright/test'
+import dotenv from 'dotenv'
+
+// Load environment variables from .env.local
+dotenv.config({ path: '.env.local' })
+
+export default defineConfig({
+  testDir: './tests',
+  // Run tests in parallel by default
+  fullyParallel: true,
+  // Fail the build on CI if you accidentally left test.only in the source code
+  forbidOnly: !!process.env.CI,
+  // Retry on CI only
+  retries: process.env.CI ? 2 : 0,
+  // Use single worker in CI for stability with real API calls
+  workers: process.env.CI ? 1 : undefined,
+  // Reporter configuration
+  reporter: [['html', { open: 'never' }], ['list']],
+  // Extended timeout for real API calls (60 seconds per test)
+  timeout: 60_000,
+  // Expect timeout for assertions
+  expect: {
+    timeout: 30_000,
+  },
+  use: {
+    // Base URL for the testing panel
+    baseURL: 'http://localhost:3010',
+    // Collect trace on first retry
+    trace: 'on-first-retry',
+    // Screenshot on failure
+    screenshot: 'only-on-failure',
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+  ],
+  // Start the dev server before running tests
+  webServer: {
+    command: 'pnpm run dev',
+    url: 'http://localhost:3010',
+    reuseExistingServer: !process.env.CI,
+    timeout: 120_000,
+  },
+})
diff --git a/testing/panel/src/lib/model-selection.ts b/testing/panel/src/lib/model-selection.ts
index 4d40ccc7..1efc2ab3 100644
--- a/testing/panel/src/lib/model-selection.ts
+++ b/testing/panel/src/lib/model-selection.ts
@@ -1,4 +1,10 @@
-export type Provider = 'openai' | 'anthropic' | 'gemini' | 'ollama' | 'grok'
+export type Provider =
+  | 'openai'
+  | 'anthropic'
+  | 'gemini'
+  | 'ollama'
+  | 'grok'
+  | 'openrouter'
 
 export interface ModelOption {
   provider: Provider
@@ -32,13 +38,18 @@ export const MODEL_OPTIONS: Array<ModelOption> = [
   // Gemini
   {
     provider: 'gemini',
-    model: 'gemini-2.0-flash-exp',
+    model: 'gemini-2.0-flash',
     label: 'Gemini - 2.0 Flash',
   },
   {
     provider: 'gemini',
-    model: 'gemini-exp-1206',
-    label: 'Gemini - Exp 1206 (Pro)',
+    model: 'gemini-2.5-flash',
+    label: 'Gemini - 2.5 Flash',
+  },
+  {
+    provider: 'gemini',
+    model: 'gemini-2.5-pro',
+    label: 'Gemini - 2.5 Pro',
   },
 
   // Ollama
@@ -69,6 +80,16 @@ export const MODEL_OPTIONS: Array<ModelOption> = [
   },
 
   // Grok
+  {
+    provider: 'grok',
+    model: 'grok-4',
+    label: 'Grok - Grok 4',
+  },
+  {
+    provider: 'grok',
+    model: 'grok-4-fast-non-reasoning',
+    label: 'Grok - Grok 4 Fast',
+  },
   {
     provider: 'grok',
     model: 'grok-3',
@@ -79,47 +100,30 @@ export const MODEL_OPTIONS: Array<ModelOption> = [
     model: 'grok-3-mini',
     label: 'Grok - Grok 3 Mini',
   },
+
+  // OpenRouter
+  {
+    provider: 'openrouter',
+    model: 'openai/gpt-4o',
+    label: 'OpenRouter - GPT-4o',
+  },
   {
-    provider: 'grok',
-    model: 'grok-2-vision-1212',
-    label: 'Grok - Grok 2 Vision',
+    provider: 'openrouter',
+    model: 'anthropic/claude-sonnet-4',
+    label: 'OpenRouter - Claude Sonnet 4',
+  },
+  {
+    provider: 'openrouter',
+    model: 'google/gemini-2.0-flash-001',
+    label: 'OpenRouter - Gemini 2.0 Flash',
+  },
+  {
+    provider: 'openrouter',
+    model: 'meta-llama/llama-3.3-70b-instruct',
+    label: 'OpenRouter - Llama 3.3 70B',
   },
 ]
 
-const STORAGE_KEY = 'tanstack-ai-model-preference'
-
-export function getStoredModelPreference(): ModelOption | null {
-  if (typeof window === 'undefined') return null
-
-  try {
-    const stored = localStorage.getItem(STORAGE_KEY)
-    if (!stored) return null
-
-    const parsed = JSON.parse(stored) as { provider: Provider; model: string }
-    const option = MODEL_OPTIONS.find(
-      (opt) => opt.provider === parsed.provider && opt.model === parsed.model,
-    )
-
-    return option || null
-  } catch {
-    return null
-  }
-}
-
-export function setStoredModelPreference(option: ModelOption): void {
-  if (typeof window === 'undefined') return
-
-  try {
-    localStorage.setItem(
-      STORAGE_KEY,
-      JSON.stringify({ provider: option.provider, model: option.model }),
-    )
-  } catch {
-    // Ignore storage errors
-  }
-}
-
 export function getDefaultModelOption(): ModelOption {
-  const stored = getStoredModelPreference()
-  return stored || MODEL_OPTIONS[0]
+  return MODEL_OPTIONS[0]
 }
diff --git a/testing/panel/src/routes/api.chat.ts b/testing/panel/src/routes/api.chat.ts
index 4a0d29a0..11ee577c 100644
--- a/testing/panel/src/routes/api.chat.ts
+++ b/testing/panel/src/routes/api.chat.ts
@@ -12,6 +12,7 @@ import { geminiText } from '@tanstack/ai-gemini'
 import { grokText } from '@tanstack/ai-grok'
 import { openaiText } from '@tanstack/ai-openai'
 import { ollamaText } from '@tanstack/ai-ollama'
+import { openRouterText } from '@tanstack/ai-openrouter'
 import type { AIAdapter, StreamChunk } from '@tanstack/ai'
 import type { ChunkRecording } from '@/lib/recording'
 import {
@@ -52,7 +53,13 @@ const addToCartToolServer = addToCartToolDef.server((args) => ({
   totalItems: args.quantity,
 }))
 
-type Provider = 'openai' | 'anthropic' | 'gemini' | 'ollama' | 'grok'
+type Provider =
+  | 'openai'
+  | 'anthropic'
+  | 'gemini'
+  | 'ollama'
+  | 'grok'
+  | 'openrouter'
 
 /**
  * Wraps an adapter to intercept chatStream and record raw chunks from the adapter
@@ -185,6 +192,10 @@ export const Route = createFileRoute('/api/chat')({
               createChatOptions({
                 adapter: openaiText((model || 'gpt-4o') as any),
               }),
+            openrouter: () =>
+              createChatOptions({
+                adapter: openRouterText((model || 'openai/gpt-4o') as any),
+              }),
           }
 
           // Get typed adapter options using createChatOptions pattern
diff --git a/testing/panel/src/routes/api.structured.ts b/testing/panel/src/routes/api.structured.ts
index c30d4604..3b692aa1 100644
--- a/testing/panel/src/routes/api.structured.ts
+++ b/testing/panel/src/routes/api.structured.ts
@@ -2,11 +2,19 @@ import { createFileRoute } from '@tanstack/react-router'
 import { chat, createChatOptions } from '@tanstack/ai'
 import { anthropicText } from '@tanstack/ai-anthropic'
 import { geminiText } from '@tanstack/ai-gemini'
+import { grokText } from '@tanstack/ai-grok'
 import { openaiText } from '@tanstack/ai-openai'
 import { ollamaText } from '@tanstack/ai-ollama'
+import { openRouterText } from '@tanstack/ai-openrouter'
 import { z } from 'zod'
 
-type Provider = 'openai' | 'anthropic' | 'gemini' | 'ollama'
+type Provider =
+  | 'openai'
+  | 'anthropic'
+  | 'gemini'
+  | 'ollama'
+  | 'grok'
+  | 'openrouter'
 
 // Schema for structured recipe output
 const RecipeSchema = z.object({
@@ -50,29 +58,49 @@ export const Route = createFileRoute('/api/structured')({
         const { recipeName, mode = 'structured' } = body
         const data = body.data || {}
         const provider: Provider = data.provider || body.provider || 'openai'
-        const model: string = data.model || body.model || 'gpt-4o'
+        // Don't set a global default - let each adapter use its own default model
+        const model: string | undefined = data.model || body.model
 
         try {
+          // Default models per provider
+          const defaultModels: Record<Provider, string> = {
+            anthropic: 'claude-sonnet-4-5',
+            gemini: 'gemini-2.0-flash',
+            grok: 'grok-3-mini',
+            ollama: 'mistral:7b',
+            openai: 'gpt-4o',
+            openrouter: 'openai/gpt-4o',
+          }
+
+          // Determine the actual model being used
+          const actualModel = model || defaultModels[provider]
+
           // Pre-define typed adapter configurations with full type inference
           // Model is passed to the adapter factory function for type-safe autocomplete
           const adapterConfig = {
             anthropic: () =>
               createChatOptions({
-                adapter: anthropicText(
-                  (model || 'claude-sonnet-4-5-20250929') as any,
-                ),
+                adapter: anthropicText(actualModel as any),
               }),
             gemini: () =>
               createChatOptions({
-                adapter: geminiText((model || 'gemini-2.0-flash-exp') as any),
+                adapter: geminiText(actualModel as any),
+              }),
+            grok: () =>
+              createChatOptions({
+                adapter: grokText(actualModel as any),
               }),
             ollama: () =>
               createChatOptions({
-                adapter: ollamaText((model || 'mistral:7b') as any),
+                adapter: ollamaText(actualModel as any),
               }),
             openai: () =>
               createChatOptions({
-                adapter: openaiText((model || 'gpt-4o') as any),
+                adapter: openaiText(actualModel as any),
+              }),
+            openrouter: () =>
+              createChatOptions({
+                adapter: openRouterText(actualModel as any),
               }),
           }
 
@@ -80,7 +108,7 @@ export const Route = createFileRoute('/api/structured')({
           const options = adapterConfig[provider]()
 
           console.log(
-            `>> ${mode} output with model: ${model} on provider: ${provider}`,
+            `>> ${mode} output with model: ${actualModel} on provider: ${provider}`,
           )
 
           if (mode === 'structured') {
@@ -101,7 +129,7 @@ export const Route = createFileRoute('/api/structured')({
                 mode: 'structured',
                 recipe: result,
                 provider,
-                model,
+                model: actualModel,
               }),
               {
                 status: 200,
@@ -139,7 +167,7 @@ Make it detailed and easy to follow.`,
                 mode: 'oneshot',
                 markdown,
                 provider,
-                model,
+                model: actualModel,
               }),
               {
                 status: 200,
diff --git a/testing/panel/src/routes/api.summarize.ts b/testing/panel/src/routes/api.summarize.ts
index 8fe7b80a..ee3ce70f 100644
--- a/testing/panel/src/routes/api.summarize.ts
+++ b/testing/panel/src/routes/api.summarize.ts
@@ -2,10 +2,18 @@ import { createFileRoute } from '@tanstack/react-router'
 import { summarize, createSummarizeOptions } from '@tanstack/ai'
 import { anthropicSummarize } from '@tanstack/ai-anthropic'
 import { geminiSummarize } from '@tanstack/ai-gemini'
+import { grokSummarize } from '@tanstack/ai-grok'
 import { openaiSummarize } from '@tanstack/ai-openai'
 import { ollamaSummarize } from '@tanstack/ai-ollama'
+import { openRouterSummarize } from '@tanstack/ai-openrouter'
 
-type Provider = 'openai' | 'anthropic' | 'gemini' | 'ollama'
+type Provider =
+  | 'openai'
+  | 'anthropic'
+  | 'gemini'
+  | 'ollama'
+  | 'grok'
+  | 'openrouter'
 
 export const Route = createFileRoute('/api/summarize')({
   server: {
@@ -20,29 +28,49 @@ export const Route = createFileRoute('/api/summarize')({
         } = body
         const data = body.data || {}
         const provider: Provider = data.provider || body.provider || 'openai'
-        const model: string = data.model || body.model || 'gpt-4o-mini'
+        // Don't set a global default - let each adapter use its own default model
+        const model: string | undefined = data.model || body.model
 
         try {
+          // Default models per provider
+          const defaultModels: Record<Provider, string> = {
+            anthropic: 'claude-sonnet-4-5',
+            gemini: 'gemini-2.0-flash',
+            grok: 'grok-3-mini',
+            ollama: 'mistral:7b',
+            openai: 'gpt-4o-mini',
+            openrouter: 'openai/gpt-4o-mini',
+          }
+
+          // Determine the actual model being used
+          const actualModel = model || defaultModels[provider]
+
           // Pre-define typed adapter configurations with full type inference
           // Model is passed to the adapter factory function for type-safe autocomplete
           const adapterConfig = {
             anthropic: () =>
               createSummarizeOptions({
-                adapter: anthropicSummarize(
-                  (model || 'claude-sonnet-4-5') as any,
-                ),
+                adapter: anthropicSummarize(actualModel as any),
               }),
             gemini: () =>
               createSummarizeOptions({
-                adapter: geminiSummarize((model || 'gemini-2.0-flash') as any),
+                adapter: geminiSummarize(actualModel as any),
+              }),
+            grok: () =>
+              createSummarizeOptions({
+                adapter: grokSummarize(actualModel as any),
               }),
             ollama: () =>
               createSummarizeOptions({
-                adapter: ollamaSummarize(model || 'mistral:7b'),
+                adapter: ollamaSummarize(actualModel),
               }),
             openai: () =>
               createSummarizeOptions({
-                adapter: openaiSummarize(model || 'gpt-4o-mini'),
+                adapter: openaiSummarize(actualModel as any),
+              }),
+            openrouter: () =>
+              createSummarizeOptions({
+                adapter: openRouterSummarize(actualModel as any),
               }),
           }
 
@@ -50,7 +78,7 @@ export const Route = createFileRoute('/api/summarize')({
           const options = adapterConfig[provider]()
 
           console.log(
-            `>> summarize with model: ${model} on provider: ${provider} (stream: ${stream})`,
+            `>> summarize with model: ${actualModel} on provider: ${provider} (stream: ${stream})`,
           )
 
           if (stream) {
@@ -73,7 +101,7 @@ export const Route = createFileRoute('/api/summarize')({
                       delta: 'delta' in chunk ? chunk.delta : undefined,
                       content: 'content' in chunk ? chunk.content : undefined,
                       provider,
-                      model,
+                      model: ('model' in chunk && chunk.model) || actualModel,
                     })
                     controller.enqueue(encoder.encode(`data: ${data}\n\n`))
                   }
@@ -113,7 +141,7 @@ export const Route = createFileRoute('/api/summarize')({
             JSON.stringify({
               summary: result.summary,
               provider,
-              model,
+              model: result.model || actualModel,
             }),
             {
               status: 200,
diff --git a/testing/panel/src/routes/index.tsx b/testing/panel/src/routes/index.tsx
index ed51a3e5..ffad7c4c 100644
--- a/testing/panel/src/routes/index.tsx
+++ b/testing/panel/src/routes/index.tsx
@@ -22,11 +22,7 @@ import {
   recommendGuitarToolDef,
 } from '@/lib/guitar-tools'
 
-import {
-  MODEL_OPTIONS,
-  getDefaultModelOption,
-  setStoredModelPreference,
-} from '@/lib/model-selection'
+import { MODEL_OPTIONS, getDefaultModelOption } from '@/lib/model-selection'
 
 import './tanchat.css'
 
@@ -500,7 +496,6 @@ function ChatPage() {
                 onChange={(e) => {
                   const option = MODEL_OPTIONS[parseInt(e.target.value)]
                   setSelectedModel(option)
-                  setStoredModelPreference(option)
                 }}
                 disabled={isLoading}
                 className="w-full rounded-lg border border-orange-500/20 bg-gray-900 px-3 py-2 text-sm text-white focus:outline-none focus:ring-2 focus:ring-orange-500/50 disabled:opacity-50"
diff --git a/testing/panel/src/routes/structured.tsx b/testing/panel/src/routes/structured.tsx
index d35a4c2c..b79ed20e 100644
--- a/testing/panel/src/routes/structured.tsx
+++ b/testing/panel/src/routes/structured.tsx
@@ -6,7 +6,13 @@ import remarkGfm from 'remark-gfm'
 
 import type { Recipe } from './api.structured'
 
-type Provider = 'openai' | 'anthropic' | 'gemini' | 'ollama'
+type Provider =
+  | 'openai'
+  | 'anthropic'
+  | 'gemini'
+  | 'ollama'
+  | 'grok'
+  | 'openrouter'
 type Mode = 'structured' | 'oneshot'
 
 interface StructuredProvider {
@@ -18,7 +24,9 @@ const PROVIDERS: Array<StructuredProvider> = [
   { id: 'openai', name: 'OpenAI (GPT-4o)' },
   { id: 'anthropic', name: 'Anthropic (Claude Sonnet)' },
   { id: 'gemini', name: 'Gemini (2.0 Flash)' },
+  { id: 'grok', name: 'Grok (Grok 3 Mini)' },
   { id: 'ollama', name: 'Ollama (Mistral 7B)' },
+  { id: 'openrouter', name: 'OpenRouter (GPT-4o)' },
 ]
 
 const SAMPLE_RECIPES = [
diff --git a/testing/panel/src/routes/summarize.tsx b/testing/panel/src/routes/summarize.tsx
index 31114e18..79073107 100644
--- a/testing/panel/src/routes/summarize.tsx
+++ b/testing/panel/src/routes/summarize.tsx
@@ -2,7 +2,13 @@ import { useState } from 'react'
 import { createFileRoute } from '@tanstack/react-router'
 import { FileText, Loader2, Zap } from 'lucide-react'
 
-type Provider = 'openai' | 'anthropic' | 'gemini' | 'ollama'
+type Provider =
+  | 'openai'
+  | 'anthropic'
+  | 'gemini'
+  | 'ollama'
+  | 'grok'
+  | 'openrouter'
 
 interface SummarizeProvider {
   id: Provider
@@ -13,7 +19,9 @@ const PROVIDERS: Array<SummarizeProvider> = [
   { id: 'openai', name: 'OpenAI (GPT-4o Mini)' },
   { id: 'anthropic', name: 'Anthropic (Claude Sonnet)' },
   { id: 'gemini', name: 'Gemini (2.0 Flash)' },
+  { id: 'grok', name: 'Grok (Grok 3 Mini)' },
   { id: 'ollama', name: 'Ollama (Mistral 7B)' },
+  { id: 'openrouter', name: 'OpenRouter (GPT-4o Mini)' },
 ]
 
 const SAMPLE_TEXT = `Artificial intelligence (AI) is intelligence demonstrated by machines, as opposed to natural intelligence displayed by animals including humans. AI research has been defined as the field of study of intelligent agents, which refers to any system that perceives its environment and takes actions that maximize its chance of achieving its goals.
@@ -61,6 +69,7 @@ function SummarizePage() {
         const reader = response.body?.getReader()
         const decoder = new TextDecoder()
         let chunks = 0
+        let accumulatedSummary = ''
 
         if (!reader) {
           throw new Error('No response body')
@@ -83,10 +92,17 @@ function SummarizePage() {
                 if (parsed.type === 'error') {
                   throw new Error(parsed.error)
                 }
-                if (parsed.type === 'content' && parsed.content) {
+                // Handle TEXT_MESSAGE_CONTENT chunks from the summarize stream
+                if (parsed.type === 'TEXT_MESSAGE_CONTENT') {
                   chunks++
                   setChunkCount(chunks)
-                  setSummary(parsed.content)
+                  // Accumulate delta or use content if provided
+                  if (parsed.delta) {
+                    accumulatedSummary += parsed.delta
+                  } else if (parsed.content) {
+                    accumulatedSummary = parsed.content
+                  }
+                  setSummary(accumulatedSummary)
                   setUsedProvider(parsed.provider)
                   setUsedModel(parsed.model)
                 }
diff --git a/testing/panel/test-results/.last-run.json b/testing/panel/test-results/.last-run.json
new file mode 100644
index 00000000..f740f7c7
--- /dev/null
+++ b/testing/panel/test-results/.last-run.json
@@ -0,0 +1,4 @@
+{
+  "status": "passed",
+  "failedTests": []
+}
diff --git a/testing/panel/tests/basic-inference.spec.ts b/testing/panel/tests/basic-inference.spec.ts
new file mode 100644
index 00000000..b7a79655
--- /dev/null
+++ b/testing/panel/tests/basic-inference.spec.ts
@@ -0,0 +1,107 @@
+/**
+ * Basic Inference E2E Tests
+ *
+ * Tests that each AI provider can respond to a simple "say hello" prompt.
+ * This validates that the adapter is correctly configured and can communicate
+ * with the vendor API.
+ */
+
+import { test, expect } from '@playwright/test'
+import {
+  PROVIDERS,
+  isProviderAvailable,
+  getInferenceCapableProviders,
+} from './vendor-config'
+import {
+  goToChatPage,
+  selectProvider,
+  sendMessage,
+  waitForResponse,
+  getAssistantMessage,
+  getMessages,
+} from './helpers'
+
+// Only test providers that support basic inference
+const inferenceProviders = PROVIDERS.filter((p) => p.supportsBasicInference)
+
+for (const provider of inferenceProviders) {
+  test.describe(`${provider.name} - Basic Inference`, () => {
+    // Skip the entire describe block if provider is not available
+    test.skip(
+      () => !isProviderAvailable(provider),
+      `${provider.name} API key not configured (requires ${provider.envKey || 'no key'})`,
+    )
+
+    test('should respond to a simple hello prompt', async ({ page }) => {
+      // Navigate to the chat page
+      await goToChatPage(page)
+
+      // Select the provider and model
+      await selectProvider(page, provider.id, provider.defaultModel)
+
+      // Send a simple prompt
+      await sendMessage(
+        page,
+        'Say hello in a friendly way. Just respond with a greeting.',
+      )
+
+      // Wait for the response
+      await waitForResponse(page, 60_000)
+
+      // Get the assistant's response
+      const response = await getAssistantMessage(page)
+
+      // Verify we got a response
+      expect(response).toBeTruthy()
+      expect(response.length).toBeGreaterThan(0)
+
+      // The response should contain some form of greeting
+      // We're flexible here since different models respond differently
+      const lowerResponse = response.toLowerCase()
+      const hasGreeting =
+        lowerResponse.includes('hello') ||
+        lowerResponse.includes('hi') ||
+        lowerResponse.includes('hey') ||
+        lowerResponse.includes('greetings') ||
+        lowerResponse.includes('welcome')
+
+      expect(hasGreeting).toBe(true)
+    })
+
+    test('should handle a follow-up question', async ({ page }) => {
+      // Navigate to the chat page
+      await goToChatPage(page)
+
+      // Select the provider and model
+      await selectProvider(page, provider.id, provider.defaultModel)
+
+      // Send first message
+      await sendMessage(page, 'What is 2 + 2? Just give me the number.')
+
+      // Wait for response
+      await waitForResponse(page, 60_000)
+
+      // Get all messages to verify structure
+      const messages = await getMessages(page)
+
+      // Verify we have at least 2 messages (user + assistant)
+      expect(messages.length).toBeGreaterThanOrEqual(2)
+
+      // Get assistant response
+      const response = await getAssistantMessage(page)
+
+      // Verify we got a non-empty response that's not the user's message
+      expect(response).toBeTruthy()
+      expect(response).not.toContain('What is 2 + 2')
+
+      // Response should contain "4" in some form
+      expect(response).toContain('4')
+    })
+  })
+}
+
+// Test that at least one provider is available
+test('at least one provider should be available', async () => {
+  const availableProviders = PROVIDERS.filter(isProviderAvailable)
+  expect(availableProviders.length).toBeGreaterThan(0)
+})
diff --git a/testing/panel/tests/helpers.ts b/testing/panel/tests/helpers.ts
new file mode 100644
index 00000000..60dfb574
--- /dev/null
+++ b/testing/panel/tests/helpers.ts
@@ -0,0 +1,395 @@
+/**
+ * Test helpers for E2E vendor tests
+ */
+
+import type { Page, APIRequestContext } from '@playwright/test'
+import type { ProviderId, ProviderConfig } from './vendor-config'
+
+/**
+ * Select a provider/model from the model dropdown on the chat page
+ */
+export async function selectProvider(
+  page: Page,
+  provider: ProviderId,
+  model: string,
+): Promise<void> {
+  // The model selector shows labels like "OpenAI - GPT-4o"
+  // We need to find the option that matches our provider and model
+  const select = page.locator('select').first()
+  await select.waitFor({ state: 'visible' })
+
+  // Get all options and find the one matching our provider/model
+  const options = await select.locator('option').all()
+  let targetIndex = -1
+
+  for (let i = 0; i < options.length; i++) {
+    const text = await options[i].textContent()
+    // Match by provider name in the label (e.g., "OpenAI - GPT-4o")
+    const providerName = getProviderDisplayName(provider)
+    if (text?.includes(providerName) && text?.includes(model)) {
+      targetIndex = i
+      break
+    }
+    // Also match if model contains the text (for models like "gpt-4o-mini")
+    if (text?.includes(providerName)) {
+      // Check if this is the model we want by looking at model substring
+      const modelPart = model.split('/').pop() || model // Handle openrouter models like "openai/gpt-4o"
+      if (text?.toLowerCase().includes(modelPart.toLowerCase())) {
+        targetIndex = i
+        break
+      }
+    }
+  }
+
+  // If we found a match, select it; otherwise try to find by provider only
+  if (targetIndex === -1) {
+    for (let i = 0; i < options.length; i++) {
+      const text = await options[i].textContent()
+      const providerName = getProviderDisplayName(provider)
+      if (text?.includes(providerName)) {
+        targetIndex = i
+        break
+      }
+    }
+  }
+
+  if (targetIndex >= 0) {
+    await select.selectOption({ index: targetIndex })
+  } else {
+    throw new Error(
+      `Could not find model option for provider: ${provider}, model: ${model}`,
+    )
+  }
+}
+
+/**
+ * Get the display name for a provider (as shown in the UI)
+ */
+function getProviderDisplayName(provider: ProviderId): string {
+  const names: Record<ProviderId, string> = {
+    openai: 'OpenAI',
+    anthropic: 'Anthropic',
+    gemini: 'Gemini',
+    ollama: 'Ollama',
+    grok: 'Grok',
+    openrouter: 'OpenRouter',
+  }
+  return names[provider]
+}
+
+/**
+ * Send a message in the chat UI
+ */
+export async function sendMessage(page: Page, message: string): Promise<void> {
+  // Find the textarea input
+  const textarea = page.locator('textarea').first()
+  await textarea.waitFor({ state: 'visible' })
+
+  // Click to focus and clear any existing content
+  await textarea.click()
+  await textarea.fill('')
+
+  // Type the message character by character to properly trigger React state updates
+  await textarea.pressSequentially(message, { delay: 10 })
+
+  // Verify the input has the message
+  await textarea.waitFor({ state: 'visible' })
+
+  // Use keyboard Enter to send (more reliable than finding the button)
+  // The chat UI handles Enter key to send messages
+  await textarea.press('Enter')
+}
+
+/**
+ * Wait for the assistant response to complete
+ */
+export async function waitForResponse(
+  page: Page,
+  timeout: number = 60_000,
+): Promise<void> {
+  // Wait for loading to start - the stop button should appear or we see loading indicator
+  const stopButton = page.locator('button:has-text("Stop")')
+
+  // First, wait a moment for loading to potentially start
+  await page.waitForTimeout(1000)
+
+  // Check if loading started by looking for the stop button
+  const loadingStarted = await stopButton.isVisible().catch(() => false)
+
+  if (loadingStarted) {
+    // Wait for loading to complete (stop button to disappear)
+    try {
+      await stopButton.waitFor({ state: 'hidden', timeout: timeout - 1000 })
+    } catch {
+      // Stop button might still be visible if test times out
+    }
+  } else {
+    // Loading might have been too fast or there's an error
+    // Wait for either an assistant message or an error to appear
+    const messagesJson = page
+      .locator('pre')
+      .filter({ hasText: '"role"' })
+      .first()
+    try {
+      // Wait for the messages JSON to contain an assistant message
+      await page.waitForFunction(
+        () => {
+          const preElements = document.querySelectorAll('pre')
+          for (const pre of preElements) {
+            const text = pre.textContent || ''
+            if (text.includes('"assistant"')) {
+              return true
+            }
+          }
+          return false
+        },
+        { timeout: timeout - 1000 },
+      )
+    } catch {
+      // Timeout waiting for response
+    }
+  }
+
+  // Additional wait for message to fully render
+  await page.waitForTimeout(500)
+}
+
+/**
+ * Get the last assistant message text from the chat
+ */
+export async function getAssistantMessage(page: Page): Promise<string> {
+  // First try to get messages from the debug panel JSON
+  const messages = await getMessages(page)
+
+  // Find the last assistant message (searching from the end)
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]
+    if (msg.role === 'assistant') {
+      // Extract text content from parts
+      const textParts = msg.parts?.filter(
+        (p: any) => p.type === 'text' && p.content,
+      )
+      if (textParts?.length > 0) {
+        return textParts.map((p: any) => p.content).join(' ')
+      }
+      // If no text parts, check if there's direct content
+      if (msg.content) {
+        return msg.content
+      }
+    }
+  }
+
+  // Fallback: try to get text from the rendered chat messages
+  // Look for the AI indicator badge and get the adjacent prose content
+  try {
+    // The chat shows messages with an "AI" badge for assistant messages
+    // Get all message containers and find ones with assistant role indicator
+    const aiMessages = page.locator('.rounded-lg.mb-2').filter({
+      has: page.locator('text="AI"'),
+    })
+    const count = await aiMessages.count()
+    if (count > 0) {
+      const lastAiMessage = aiMessages.last()
+      const proseContent = lastAiMessage.locator('.prose')
+      if ((await proseContent.count()) > 0) {
+        const textContent = await proseContent
+          .first()
+          .textContent({ timeout: 5000 })
+        return textContent || ''
+      }
+    }
+  } catch {
+    // Ignore errors in fallback
+  }
+
+  return ''
+}
+
+/**
+ * Get all messages as parsed JSON from the debug panel
+ */
+export async function getMessages(page: Page): Promise<any[]> {
+  const messagesJson = page.locator('pre').filter({ hasText: '"role"' }).first()
+
+  try {
+    const jsonText = await messagesJson.textContent({ timeout: 5000 })
+    if (jsonText) {
+      return JSON.parse(jsonText)
+    }
+  } catch {
+    // Return empty array if parsing fails
+  }
+
+  return []
+}
+
+/**
+ * Check if the last message has tool calls
+ */
+export async function hasToolCalls(page: Page): Promise<boolean> {
+  const messages = await getMessages(page)
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === 'assistant') {
+      const toolCalls = messages[i].parts?.filter(
+        (p: any) => p.type === 'tool-call',
+      )
+      return toolCalls?.length > 0
+    }
+  }
+  return false
+}
+
+/**
+ * Get tool call names from the last assistant message
+ */
+export async function getToolCallNames(page: Page): Promise<string[]> {
+  const messages = await getMessages(page)
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === 'assistant') {
+      const toolCalls = messages[i].parts?.filter(
+        (p: any) => p.type === 'tool-call',
+      )
+      return toolCalls?.map((tc: any) => tc.name) || []
+    }
+  }
+  return []
+}
+
+/**
+ * Options for summarization API call
+ */
+export interface SummarizeOptions {
+  text: string
+  provider: ProviderId
+  model?: string
+  maxLength?: number
+  style?: 'concise' | 'detailed' | 'bullet-points'
+  stream?: boolean
+}
+
+/**
+ * Call the summarize API directly (non-streaming)
+ */
+export async function callSummarizeAPI(
+  request: APIRequestContext,
+  baseURL: string,
+  options: SummarizeOptions,
+): Promise<{ summary: string; provider: string; model: string }> {
+  const response = await request.post(`${baseURL}/api/summarize`, {
+    data: {
+      text: options.text,
+      provider: options.provider,
+      model: options.model,
+      maxLength: options.maxLength || 100,
+      style: options.style || 'concise',
+      stream: false,
+    },
+  })
+
+  if (!response.ok()) {
+    const errorBody = await response.text()
+    throw new Error(`Summarize API failed: ${response.status()} - ${errorBody}`)
+  }
+
+  return response.json()
+}
+
+/**
+ * Call the summarize API with streaming
+ */
+export async function callSummarizeAPIStreaming(
+  request: APIRequestContext,
+  baseURL: string,
+  options: SummarizeOptions,
+): Promise<{
+  summary: string
+  provider: string
+  model: string
+  chunkCount: number
+}> {
+  const response = await request.post(`${baseURL}/api/summarize`, {
+    data: {
+      text: options.text,
+      provider: options.provider,
+      model: options.model,
+      maxLength: options.maxLength || 100,
+      style: options.style || 'concise',
+      stream: true,
+    },
+  })
+
+  if (!response.ok()) {
+    const errorBody = await response.text()
+    throw new Error(
+      `Summarize API streaming failed: ${response.status()} - ${errorBody}`,
+    )
+  }
+
+  // Parse SSE response
+  const text = await response.text()
+  const lines = text.split('\n')
+
+  let summary = ''
+  let provider = ''
+  let model = ''
+  let chunkCount = 0
+
+  for (const line of lines) {
+    if (line.startsWith('data: ')) {
+      const data = line.slice(6)
+      if (data === '[DONE]') continue
+
+      try {
+        const parsed = JSON.parse(data)
+        if (parsed.type === 'error') {
+          throw new Error(parsed.error)
+        }
+        if (parsed.type === 'TEXT_MESSAGE_CONTENT') {
+          chunkCount++
+          if (parsed.delta) {
+            summary += parsed.delta
+          } else if (parsed.content) {
+            summary = parsed.content
+          }
+          provider = parsed.provider || provider
+          model = parsed.model || model
+        }
+      } catch {
+        // Ignore parse errors
+      }
+    }
+  }
+
+  return { summary, provider, model, chunkCount }
+}
+
+/**
+ * Sample text for summarization tests
+ */
+export const SAMPLE_TEXT_FOR_SUMMARIZATION = `Artificial intelligence (AI) is intelligence demonstrated by machines, as opposed to natural intelligence displayed by animals including humans. AI research has been defined as the field of study of intelligent agents, which refers to any system that perceives its environment and takes actions that maximize its chance of achieving its goals.
+
+The term "artificial intelligence" had previously been used to describe machines that mimic and display "human" cognitive skills that are associated with the human mind, such as "learning" and "problem-solving". This definition has since been rejected by major AI researchers who now describe AI in terms of rationality and acting rationally, which does not limit how intelligence can be articulated.
+
+AI applications include advanced web search engines, recommendation systems, understanding human speech, self-driving cars, automated decision-making and competing at the highest level in strategic game systems. As machines become increasingly capable, tasks considered to require "intelligence" are often removed from the definition of AI, a phenomenon known as the AI effect.`
+
+/**
+ * Navigate to the chat page and wait for it to load
+ */
+export async function goToChatPage(page: Page): Promise<void> {
+  await page.goto('/')
+  // Wait for the model selector to be visible
+  await page.locator('select').first().waitFor({ state: 'visible' })
+  // Wait a bit for hydration
+  await page.waitForTimeout(500)
+}
+
+/**
+ * Navigate to the summarize page and wait for it to load
+ */
+export async function goToSummarizePage(page: Page): Promise<void> {
+  await page.goto('/summarize')
+  // Wait for the provider selector to be visible
+  await page.locator('select').first().waitFor({ state: 'visible' })
+  // Wait a bit for hydration
+  await page.waitForTimeout(500)
+}
diff --git a/testing/panel/tests/summarization.spec.ts b/testing/panel/tests/summarization.spec.ts
new file mode 100644
index 00000000..9cf45c63
--- /dev/null
+++ b/testing/panel/tests/summarization.spec.ts
@@ -0,0 +1,184 @@
+/**
+ * Summarization E2E Tests
+ *
+ * Tests the summarization API endpoint with both streaming and non-streaming modes
+ * across all providers.
+ */
+
+import { test, expect } from '@playwright/test'
+import {
+  PROVIDERS,
+  isProviderAvailable,
+  getSummarizationCapableProviders,
+  getStreamingSummarizationCapableProviders,
+} from './vendor-config'
+import {
+  callSummarizeAPI,
+  callSummarizeAPIStreaming,
+  SAMPLE_TEXT_FOR_SUMMARIZATION,
+} from './helpers'
+
+const BASE_URL = 'http://localhost:3010'
+
+// Test non-streaming summarization for each provider
+for (const provider of PROVIDERS.filter((p) => p.supportsSummarization)) {
+  test.describe(`${provider.name} - Non-Streaming Summarization`, () => {
+    // Skip if provider is not available
+    test.skip(
+      () => !isProviderAvailable(provider),
+      `${provider.name} API key not configured (requires ${provider.envKey || 'no key'})`,
+    )
+
+    test('should summarize text successfully', async ({ request }) => {
+      const result = await callSummarizeAPI(request, BASE_URL, {
+        text: SAMPLE_TEXT_FOR_SUMMARIZATION,
+        provider: provider.id,
+        maxLength: 100,
+        style: 'concise',
+      })
+
+      // Verify we got a summary
+      expect(result.summary).toBeTruthy()
+      expect(result.summary.length).toBeGreaterThan(0)
+
+      // Summary should be shorter than the original text
+      expect(result.summary.length).toBeLessThan(
+        SAMPLE_TEXT_FOR_SUMMARIZATION.length,
+      )
+
+      // Verify provider info is returned
+      expect(result.provider).toBe(provider.id)
+      expect(result.model).toBeTruthy()
+    })
+
+    test('should handle different summary styles', async ({ request }) => {
+      // Test bullet-points style
+      const result = await callSummarizeAPI(request, BASE_URL, {
+        text: SAMPLE_TEXT_FOR_SUMMARIZATION,
+        provider: provider.id,
+        maxLength: 150,
+        style: 'bullet-points',
+      })
+
+      expect(result.summary).toBeTruthy()
+    })
+
+    test('should respect maxLength parameter', async ({ request }) => {
+      // Request a very short summary
+      const result = await callSummarizeAPI(request, BASE_URL, {
+        text: SAMPLE_TEXT_FOR_SUMMARIZATION,
+        provider: provider.id,
+        maxLength: 30,
+        style: 'concise',
+      })
+
+      expect(result.summary).toBeTruthy()
+
+      // The summary should be reasonably short (models don't always respect exact limits)
+      // We'll just verify it's significantly shorter than the input
+      expect(result.summary.length).toBeLessThan(
+        SAMPLE_TEXT_FOR_SUMMARIZATION.length / 2,
+      )
+    })
+  })
+}
+
+// Test streaming summarization for each provider that supports it
+for (const provider of PROVIDERS.filter(
+  (p) => p.supportsStreamingSummarization,
+)) {
+  test.describe(`${provider.name} - Streaming Summarization`, () => {
+    // Skip if provider is not available
+    test.skip(
+      () => !isProviderAvailable(provider),
+      `${provider.name} API key not configured (requires ${provider.envKey || 'no key'})`,
+    )
+
+    test('should stream summary chunks', async ({ request }) => {
+      const result = await callSummarizeAPIStreaming(request, BASE_URL, {
+        text: SAMPLE_TEXT_FOR_SUMMARIZATION,
+        provider: provider.id,
+        maxLength: 100,
+        style: 'concise',
+      })
+
+      // Verify we got a summary
+      expect(result.summary).toBeTruthy()
+      expect(result.summary.length).toBeGreaterThan(0)
+
+      // Verify we received multiple chunks (streaming)
+      expect(result.chunkCount).toBeGreaterThan(0)
+
+      // Verify provider info
+      expect(result.provider).toBe(provider.id)
+      expect(result.model).toBeTruthy()
+    })
+
+    test('should produce same quality summary as non-streaming', async ({
+      request,
+    }) => {
+      // Get non-streaming summary
+      const nonStreaming = await callSummarizeAPI(request, BASE_URL, {
+        text: SAMPLE_TEXT_FOR_SUMMARIZATION,
+        provider: provider.id,
+        maxLength: 100,
+        style: 'concise',
+      })
+
+      // Get streaming summary
+      const streaming = await callSummarizeAPIStreaming(request, BASE_URL, {
+        text: SAMPLE_TEXT_FOR_SUMMARIZATION,
+        provider: provider.id,
+        maxLength: 100,
+        style: 'concise',
+      })
+
+      // Both should produce valid summaries
+      expect(nonStreaming.summary).toBeTruthy()
+      expect(streaming.summary).toBeTruthy()
+
+      // Both should be reasonably sized (similar length, within 50% of each other)
+      const ratio =
+        streaming.summary.length / Math.max(nonStreaming.summary.length, 1)
+      expect(ratio).toBeGreaterThan(0.3)
+      expect(ratio).toBeLessThan(3)
+    })
+  })
+}
+
+// Test error handling
+test.describe('Summarization Error Handling', () => {
+  test('should handle empty text gracefully', async ({ request }) => {
+    // Get the first available provider
+    const availableProviders = getSummarizationCapableProviders()
+    test.skip(
+      availableProviders.length === 0,
+      'No summarization providers available',
+    )
+
+    const provider = availableProviders[0]
+
+    try {
+      await callSummarizeAPI(request, BASE_URL, {
+        text: '',
+        provider: provider.id,
+        maxLength: 100,
+      })
+      // If we get here, the API didn't reject empty text - that's also acceptable
+    } catch (error: any) {
+      // Error is expected for empty text
+      expect(error.message).toBeTruthy()
+    }
+  })
+})
+
+// Verify providers are available
+test('at least one summarization provider should be available', async () => {
+  const available = getSummarizationCapableProviders()
+  expect(available.length).toBeGreaterThanOrEqual(0)
+})
+
+test('at least one streaming summarization provider should be available', async () => {
+  const available = getStreamingSummarizationCapableProviders()
+  expect(available.length).toBeGreaterThanOrEqual(0)
+})
diff --git a/testing/panel/tests/tool-flow.spec.ts b/testing/panel/tests/tool-flow.spec.ts
new file mode 100644
index 00000000..03058ccd
--- /dev/null
+++ b/testing/panel/tests/tool-flow.spec.ts
@@ -0,0 +1,154 @@
+/**
+ * Tool Flow E2E Tests
+ *
+ * Tests that AI providers can correctly invoke tools when prompted.
+ * Uses the existing guitar recommendation tools in the testing panel.
+ *
+ * The guitar store system prompt instructs the AI to:
+ * 1. Call getGuitars() to fetch inventory
+ * 2. Call recommendGuitar(id) to display a recommendation
+ */
+
+import { test, expect } from '@playwright/test'
+import {
+  PROVIDERS,
+  isProviderAvailable,
+  getToolCapableProviders,
+} from './vendor-config'
+import {
+  goToChatPage,
+  selectProvider,
+  sendMessage,
+  waitForResponse,
+  getMessages,
+  hasToolCalls,
+  getToolCallNames,
+} from './helpers'
+
+// Only test providers that support tool calling
+const toolProviders = PROVIDERS.filter((p) => p.supportsTools)
+
+for (const provider of toolProviders) {
+  test.describe(`${provider.name} - Tool Flow`, () => {
+    // Skip if provider is not available
+    test.skip(
+      () => !isProviderAvailable(provider),
+      `${provider.name} API key not configured (requires ${provider.envKey || 'no key'})`,
+    )
+
+    test('should call getGuitars tool when asked for guitar recommendation', async ({
+      page,
+    }) => {
+      // Navigate to the chat page
+      await goToChatPage(page)
+
+      // Select the provider and model
+      await selectProvider(page, provider.id, provider.defaultModel)
+
+      // Send a prompt that should trigger tool calls
+      await sendMessage(
+        page,
+        'Use the getGuitars tool to show me what guitars you have in inventory.',
+      )
+
+      // Wait for the response (tool calls may take longer)
+      await waitForResponse(page, 90_000)
+
+      // Check that tool calls were made
+      const madeToolCalls = await hasToolCalls(page)
+
+      expect(madeToolCalls).toBe(true)
+
+      // Verify getGuitars was called
+      const toolNames = await getToolCallNames(page)
+      expect(toolNames).toContain('getGuitars')
+    })
+
+    test('should complete full recommendation flow with multiple tool calls', async ({
+      page,
+    }) => {
+      // Navigate to the chat page
+      await goToChatPage(page)
+
+      // Select the provider and model
+      await selectProvider(page, provider.id, provider.defaultModel)
+
+      // Send a prompt that should trigger the full flow
+      await sendMessage(
+        page,
+        'Recommend me an electric guitar from your inventory.',
+      )
+
+      // Wait for the response (multiple tool calls may take longer)
+      await waitForResponse(page, 120_000)
+
+      // Get all messages to inspect the tool calls
+      const messages = await getMessages(page)
+
+      // Find assistant messages with tool calls
+      const assistantMessages = messages.filter(
+        (m: any) => m.role === 'assistant',
+      )
+      expect(assistantMessages.length).toBeGreaterThan(0)
+
+      // Check that we have tool calls
+      const allToolCalls: string[] = []
+      for (const msg of assistantMessages) {
+        const toolCalls = msg.parts?.filter((p: any) => p.type === 'tool-call')
+        if (toolCalls) {
+          allToolCalls.push(...toolCalls.map((tc: any) => tc.name))
+        }
+      }
+
+      // Should have called getGuitars at minimum
+      expect(allToolCalls).toContain('getGuitars')
+    })
+
+    test('should handle tool with arguments correctly', async ({ page }) => {
+      // Navigate to the chat page
+      await goToChatPage(page)
+
+      // Select the provider and model
+      await selectProvider(page, provider.id, provider.defaultModel)
+
+      // Send a specific request that should use recommendGuitar with an ID
+      await sendMessage(
+        page,
+        'Show me the guitars you have and then recommend guitar #1 to me.',
+      )
+
+      // Wait for the response
+      await waitForResponse(page, 120_000)
+
+      // Get all messages
+      const messages = await getMessages(page)
+
+      // Find tool calls with arguments
+      const allToolCalls: Array<{ name: string; arguments?: string }> = []
+      for (const msg of messages) {
+        if (msg.role === 'assistant') {
+          const toolCalls = msg.parts?.filter(
+            (p: any) => p.type === 'tool-call',
+          )
+          if (toolCalls) {
+            for (const tc of toolCalls) {
+              allToolCalls.push({
+                name: tc.name,
+                arguments: tc.arguments,
+              })
+            }
+          }
+        }
+      }
+
+      // Should have some tool calls
+      expect(allToolCalls.length).toBeGreaterThan(0)
+    })
+  })
+}
+
+// Verify we have tool-capable providers to test
+test('at least one tool-capable provider should be available', async () => {
+  const available = getToolCapableProviders()
+  expect(available.length).toBeGreaterThanOrEqual(0)
+})
diff --git a/testing/panel/tests/vendor-config.ts b/testing/panel/tests/vendor-config.ts
new file mode 100644
index 00000000..5373d6fb
--- /dev/null
+++ b/testing/panel/tests/vendor-config.ts
@@ -0,0 +1,160 @@
+/**
+ * Vendor configuration for E2E tests
+ *
+ * Defines all supported AI providers and their configuration for testing.
+ */
+
+export type ProviderId =
+  | 'openai'
+  | 'anthropic'
+  | 'gemini'
+  | 'ollama'
+  | 'grok'
+  | 'openrouter'
+
+export interface ProviderConfig {
+  /** Unique identifier matching the panel's provider type */
+  id: ProviderId
+  /** Human-readable name for test descriptions */
+  name: string
+  /** Environment variable key for API key (null if not required) */
+  envKey: string | null
+  /** Default model to use for testing */
+  defaultModel: string
+  /** Whether this provider reliably supports basic chat inference */
+  supportsBasicInference: boolean
+  /** Whether this provider reliably supports tool calling */
+  supportsTools: boolean
+  /** Whether this provider supports summarization */
+  supportsSummarization: boolean
+  /** Whether this provider supports streaming summarization */
+  supportsStreamingSummarization: boolean
+}
+
+/**
+ * All supported providers and their configurations
+ */
+export const PROVIDERS: ProviderConfig[] = [
+  {
+    id: 'openai',
+    name: 'OpenAI',
+    envKey: 'OPENAI_API_KEY',
+    defaultModel: 'gpt-4o-mini',
+    supportsBasicInference: true,
+    supportsTools: true,
+    supportsSummarization: true,
+    supportsStreamingSummarization: true,
+  },
+  {
+    id: 'anthropic',
+    name: 'Anthropic',
+    envKey: 'ANTHROPIC_API_KEY',
+    defaultModel: 'claude-sonnet-4-5-20250929',
+    supportsBasicInference: true,
+    supportsTools: true,
+    supportsSummarization: true,
+    supportsStreamingSummarization: true,
+  },
+  {
+    id: 'gemini',
+    name: 'Gemini',
+    envKey: 'GEMINI_API_KEY',
+    defaultModel: 'gemini-2.0-flash',
+    supportsBasicInference: true,
+    supportsTools: true,
+    supportsSummarization: true,
+    supportsStreamingSummarization: true,
+  },
+  {
+    id: 'ollama',
+    name: 'Ollama',
+    envKey: null, // Ollama runs locally, no API key needed
+    defaultModel: 'mistral:7b',
+    supportsBasicInference: true,
+    supportsTools: false, // Smaller local models may not reliably call tools
+    supportsSummarization: true,
+    supportsStreamingSummarization: true,
+  },
+  {
+    id: 'grok',
+    name: 'Grok',
+    envKey: 'XAI_API_KEY',
+    defaultModel: 'grok-3-mini',
+    supportsBasicInference: true,
+    supportsTools: true,
+    supportsSummarization: true,
+    supportsStreamingSummarization: true,
+  },
+  {
+    id: 'openrouter',
+    name: 'OpenRouter',
+    envKey: 'OPENROUTER_API_KEY',
+    defaultModel: 'openai/gpt-4o-mini',
+    supportsBasicInference: false, // Chat via OpenRouter returns empty responses inconsistently
+    supportsTools: false, // Tool calling via OpenRouter is unreliable due to backend variations
+    supportsSummarization: true,
+    supportsStreamingSummarization: true,
+  },
+]
+
+/**
+ * Check if a provider is available (has required API key configured)
+ */
+export function isProviderAvailable(provider: ProviderConfig): boolean {
+  // Ollama doesn't require an API key
+  if (provider.envKey === null) {
+    return true
+  }
+
+  // Check for the API key in environment
+  const apiKey = process.env[provider.envKey]
+  return Boolean(apiKey && apiKey.length > 0)
+}
+
+/**
+ * Get a provider by ID
+ */
+export function getProvider(id: ProviderId): ProviderConfig | undefined {
+  return PROVIDERS.find((p) => p.id === id)
+}
+
+/**
+ * Get all available providers (those with API keys configured)
+ */
+export function getAvailableProviders(): ProviderConfig[] {
+  return PROVIDERS.filter(isProviderAvailable)
+}
+
+/**
+ * Get providers that support basic inference (chat)
+ */
+export function getInferenceCapableProviders(): ProviderConfig[] {
+  return PROVIDERS.filter(
+    (p) => p.supportsBasicInference && isProviderAvailable(p),
+  )
+}
+
+/**
+ * Get providers that support tool calling
+ */
+export function getToolCapableProviders(): ProviderConfig[] {
+  return PROVIDERS.filter((p) => p.supportsTools && isProviderAvailable(p))
+}
+
+/**
+ * Get providers that support summarization
+ */
+export function getSummarizationCapableProviders(): ProviderConfig[] {
+  return PROVIDERS.filter(
+    (p) => p.supportsSummarization && isProviderAvailable(p),
+  )
+}
+
+/**
+ * Get providers that support streaming summarization
+ */
+export function getStreamingSummarizationCapableProviders(): ProviderConfig[] {
+  return PROVIDERS.filter(
+    (p) => p.supportsStreamingSummarization && isProviderAvailable(p),
+  )
+}